@scandipwa/magento-scripts 1.16.1 → 2.0.0-alpha.2

package/lib/tasks/status/index.js

@@ -25,19 +25,16 @@ const parsePort = (port) => {
 const prettyStatus = async (ctx) => {
     const {
         config: {
-            baseConfig,
-            php,
-            composer
+            baseConfig
         },
         magentoVersion,
         dockerVersion,
-        PHPBrewVersion,
         platform,
         platformVersion,
         containers
     } = ctx;
     const projectCreatedAt = getProjectCreatedAt();
-    const composerVersion = await getComposerVersion({ composer, php });
+    const composerVersion = await getComposerVersion(ctx);
 
     const prefix = getPrefix();
 
@@ -48,7 +45,7 @@ const prettyStatus = async (ctx) => {
     block
         .addHeader(`magento-scripts version: ${ logger.style.link(packageVersion) }`)
         .addEmptyLine()
-        .addLine(`Project: ${logger.style.file(baseConfig.prefix)} ${prefix === folderName ? '(without prefix)' : '(with prefix)'}`)
+        .addLine(`Project: ${logger.style.file(baseConfig.prefix)} ${prefix === folderName ? '(without prefix)' : '(with prefix)'} (with php container)`)
         .addLine(`Project location: ${logger.style.link(process.cwd())}`);
 
     if (projectCreatedAt) {
@@ -57,12 +54,9 @@ const prettyStatus = async (ctx) => {
 
     block
         .addLine(`Magento 2 version: ${logger.style.file(magentoVersion)}`)
-        .addLine(`PHP version: ${logger.style.file(php.version)}`)
-        .addLine(`PHP location: ${logger.style.link(php.binPath)}`)
+        .addLine(`PHP version: ${logger.style.file(ctx.phpVersion)}`)
         .addLine(`Composer version: ${logger.style.file(composerVersion)}`)
-        .addLine(`Composer location: ${logger.style.link(path.relative(process.cwd(), composer.binPath))}`)
         .addLine(`Docker version: ${logger.style.file(dockerVersion)}`)
-        .addLine(`PHPBrew version: ${logger.style.file(PHPBrewVersion)}`)
         .addLine(`Platform: ${logger.style.code(platform)}`)
         .addLine(`Platform version: ${logger.style.file(platformVersion)}`)
         .addLine(`Platform architecture: ${logger.style.file(getArchSync())}`)
@@ -79,8 +73,10 @@ const prettyStatus = async (ctx) => {
 
         if (container.status && container.status.Health) {
             containerStatus = `✓ ${ logger.style.file(container.status.Health.Status) } and ${ logger.style.file('running') }`;
-        } else {
+        } else if (container.status) {
             containerStatus = logger.style.file(container.status.Status);
+        } else {
+            containerStatus = '✖ Not running';
         }
 
         block
@@ -89,7 +85,7 @@ const prettyStatus = async (ctx) => {
             .addLine(`Image: ${logger.style.file(container.image)}`)
             .addLine(`Network: ${logger.style.link(container.network)}`);
 
-        if (container.forwardedPorts && container.forwardedPorts.length > 0) {
+        if (!containerStatus.includes('Not running') && container.forwardedPorts && container.forwardedPorts.length > 0) {
             block.addLine('Port forwarding:');
             container.forwardedPorts.forEach((port) => {
                 const { host, hostPort, containerPort } = parsePort(port);

package/lib/tasks/stop.js

@@ -1,6 +1,5 @@
 const { stopServices } = require('./docker');
 const getMagentoVersionConfig = require('../config/get-magento-version-config');
-const { stopPhpFpm } = require('./php-fpm');
 const getProjectConfiguration = require('../config/get-project-configuration');
 const checkConfigurationFile = require('../config/check-configuration-file');
 
@@ -13,7 +12,6 @@ const stop = () => ({
         getMagentoVersionConfig(),
         checkConfigurationFile(),
         getProjectConfiguration(),
-        stopPhpFpm(),
         stopServices()
     ], {
         concurrent: false,

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

@@ -18,7 +18,7 @@ const installTheme = (theme) => ({
         }
 
         try {
-            await runComposerCommand(`require ${theme.composerData.name}`, {
+            await runComposerCommand(ctx, `require ${theme.composerData.name}`, {
                 magentoVersion,
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;

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

@@ -18,7 +18,7 @@ const linkTheme = () => ({
             absoluteThemePath,
             themePath,
             composerData,
-            mysqlConnection
+            databaseConnection
         } = ctx;
         const {
             magento: { edition: magentoEdition },
@@ -27,7 +27,7 @@ const linkTheme = () => ({
 
         const isEnterprise = magentoEdition === 'enterprise';
         const isPageBuilderInstalled = isEnterprise && semver.satisfies(semver.coerce(magentoVersion), '^2.4');
-        const [queryResult] = await mysqlConnection.query(`
+        const [queryResult] = await databaseConnection.query(`
                 SELECT value AS isPagebuilderEnabled
                 FROM core_config_data
                 WHERE path = 'cms/pagebuilder/enabled'

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

@@ -9,7 +9,7 @@ const runComposerCommand = require('../../util/run-composer');
 const symlinkTheme = (theme) => ({
     title: 'Setting symbolic link for theme in composer.json',
     task: async (ctx, task) => {
-        const { magentoVersion, verbose = false } = ctx;
+        const { verbose = false } = ctx;
         const composerJsonData = await getJsonfileData(path.join(process.cwd(), 'composer.json'));
 
         if (!composerJsonData.repositories) {
@@ -27,8 +27,7 @@ const symlinkTheme = (theme) => ({
         }
 
         try {
-            await runComposerCommand(`config repo.scandipwa path ${theme.absoluteThemePath}`, {
-                magentoVersion,
+            await runComposerCommand(ctx, `config repo.scandipwa path ${theme.absoluteThemePath}`, {
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;
                 }

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

@@ -46,10 +46,16 @@ const sslSchema = Joi.object({
     ssl_certificate_key: Joi.string().required()
 });
 
+/**
+ * @type {Joi.ObjectSchema<import('../../typings/index').PHPExtensions>}
+ */
 const phpExtensionConfiguration = Joi.object()
     .pattern(
         Joi.string(),
         Joi.object({
+            alternativeName: Joi.array().items(Joi.string()).optional(),
+            command: Joi.func().optional(),
+            dependencies: Joi.array().items(Joi.string()).optional(),
             version: Joi.string().optional()
         })
             .unknown()
@@ -59,38 +65,47 @@ const phpExtensionConfiguration = Joi.object()
  * @type {Joi.ObjectSchema<import('../../typings').PHPConfiguration>}
  */
 const phpConfigurationSchema = Joi.object({
-    version: Joi.string().optional().custom(versionValidator),
+    baseImage: Joi.string().optional(),
+    debugImage: Joi.string().optional(),
+    fpmConfigTemplate: Joi.string().optional(),
     configTemplate: Joi.string().optional().custom(fileExistsValidator),
-    extensions: phpExtensionConfiguration.optional(),
-    disabledExtensions: Joi.array().items(Joi.string())
+    extensions: phpExtensionConfiguration.optional()
 });
 
 /**
  * @type {Joi.ObjectSchema<import('../../typings').NginxConfiguration>}
  */
 const nginxConfigurationSchema = Joi.object({
-    version: Joi.string().optional(),
+    image: Joi.string().optional(),
     configTemplate: Joi.string().optional().custom(fileExistsValidator)
 });
 
 /**
- * @type {Joi.ObjectSchema<import('../../typings').NginxConfiguration>}
+ * @type {Joi.ObjectSchema<import('../../typings').VarnishConfiguration>}
  */
 const varnishConfigurationSchema = Joi.object({
     enabled: Joi.boolean().optional(),
-    version: Joi.string().optional(),
+    image: Joi.string().optional(),
     configTemplate: Joi.string().optional().custom(fileExistsValidator)
 });
 
 /**
- * @type {Joi.ObjectSchema<import('../../typings').ServiceWithVersion>}
+ * @type {Joi.ObjectSchema<import('../../typings').ServiceWithImage>}
  */
 const serviceConfigurationSchema = Joi.object({
-    version: Joi.string().optional()
+    image: Joi.string().optional()
+});
+
+/**
+ * @type {Joi.ObjectSchema<import('../../typings').ElasticSearchConfiguration>}
+ */
+const elasticsearchConfigurationSchema = Joi.object({
+    image: Joi.string().optional(),
+    env: Joi.object().optional()
 });
 
 /**
- * @type {Joi.ObjectSchema<import('../../typings').CMAConfiguration['configuration']['composer']>}
+ * @type {Joi.ObjectSchema<import('../../typings').ComposerConfiguration>}
  */
 const composerConfigurationSchema = Joi.object({
     version: Joi.string().optional().custom((value) => {
@@ -108,8 +123,8 @@ const composerConfigurationSchema = Joi.object({
 const configurationSchema = Joi.object({
     php: phpConfigurationSchema.optional(),
     nginx: nginxConfigurationSchema.optional(),
-    mysql: serviceConfigurationSchema.optional(),
-    elasticsearch: serviceConfigurationSchema.optional(),
+    mariadb: serviceConfigurationSchema.optional(),
+    elasticsearch: elasticsearchConfigurationSchema.optional(),
     redis: serviceConfigurationSchema.optional(),
     composer: composerConfigurationSchema.optional(),
     varnish: varnishConfigurationSchema.optional(),
@@ -124,8 +139,7 @@ const configFileSchema = Joi.object({
     host: Joi.string().optional(),
     ssl: sslSchema.optional(),
     prefix: Joi.bool().optional(),
-    configuration: configurationSchema.required(),
-    useNonOverlappingPorts: Joi.bool().forbidden()
+    configuration: configurationSchema.required()
 });
 
 /**

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

@@ -1,10 +1,19 @@
 const path = require('path');
 const UnknownError = require('../errors/unknown-error');
-const runPhpCode = require('./run-php');
+const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const pathExists = require('./path-exists');
 
-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
+/**
+ * @param {import('../../typings/context').ListrContext} ctx
+ */
+const configPhpToJson = async (ctx) => {
+    const configPhpOnSystemPath = path.join(ctx.config.baseConfig.magentoDir, 'app', 'etc', 'config.php');
+    const configPhpInContainerPath = path.join(ctx.config.baseConfig.containerMagentoDir, 'app', 'etc', 'config.php');
+    if (!await pathExists(configPhpOnSystemPath)) {
+        return null;
+    }
+    const { code, result } = await runPHPContainerCommand(ctx, `php -r "echo json_encode(require '${configPhpInContainerPath}');"`, {
+        withCode: true
     });
 
     if (code !== 0) {

package/lib/util/database.js

@@ -4,8 +4,8 @@
  * @param {{path: string, value: string}[]} values
  * @param {import('../../typings/context').ListrContext} param1
  */
-const updateTableValues = async (table, values, { mysqlConnection, task }) => {
-    const [rows] = await mysqlConnection.query(`
+const updateTableValues = async (table, values, { databaseConnection, task }) => {
+    const [rows] = await databaseConnection.query(`
         SELECT * FROM ${table}
         WHERE ${values.map((p) => `path = '${p.path}'`).join(' OR ')};
     `);
@@ -13,7 +13,7 @@ const updateTableValues = async (table, values, { mysqlConnection, task }) => {
     if (rows.filter(Boolean).length !== values.length) {
         const lostConfigs = values.filter((p) => !rows.some((row) => row.path === p.path));
         for (const config of lostConfigs) {
-            await mysqlConnection.query(`
+            await databaseConnection.query(`
                 INSERT INTO ${table}
                 (scope, path, value)
                 VALUES ('default', ?, ?);
@@ -22,7 +22,7 @@ const updateTableValues = async (table, values, { mysqlConnection, task }) => {
 
         const configsToUpdate = values.filter((p) => rows.some((row) => row.path === p.path));
         for (const config of configsToUpdate) {
-            await mysqlConnection.query(`
+            await databaseConnection.query(`
                 UPDATE ${table}
                 SET value = ?
                 WHERE path = ?;
@@ -50,7 +50,7 @@ const updateTableValues = async (table, values, { mysqlConnection, task }) => {
     });
 
     for (const config of configsToUpdate) {
-        await mysqlConnection.query(`
+        await databaseConnection.query(`
             UPDATE ${table}
             SET value = ?
             WHERE path = ?;
@@ -63,11 +63,11 @@ const updateTableValues = async (table, values, { mysqlConnection, task }) => {
 * @param {String} tableName
 * @param {import('../../typings/context').ListrContext} param2
 */
-const isTableExists = async (database, tableName, { mysqlConnection }) => {
+const isTableExists = async (database, tableName, { databaseConnection }) => {
     /**
     * @type {{ tableCount: number }[][]}
     */
-    const [[{ tableCount }]] = await mysqlConnection.query(`
+    const [[{ tableCount }]] = await databaseConnection.query(`
    SELECT count(*) as tableCount
    FROM information_schema.TABLES
    WHERE (TABLE_SCHEMA = ?) AND (TABLE_NAME = ?);

package/lib/util/dockerfile-builder/build-instructions.js

@@ -0,0 +1,197 @@
+/**
+ *
+ * @param {import('./types').DockerfileInstruction[]} instructions
+ */
+const buildInstructions = (instructions) => {
+    /**
+     * @type {string[]}
+     */
+    const dockerFileInstructions = [];
+
+    for (const instruction of instructions) {
+        switch (instruction.type) {
+        case 'COPY':
+        case 'ADD': {
+            let addInstruction = instruction.type;
+
+            if (instruction.type === 'COPY' && instruction.from) {
+                addInstruction += ` --from=${instruction.from}`;
+            }
+
+            if (instruction.chown) {
+                addInstruction += ` --chown=${instruction.chown}`;
+            }
+
+            addInstruction += ` ${instruction.src.join(' ')}`;
+            addInstruction += ` ${instruction.dest}`;
+
+            dockerFileInstructions.push(addInstruction);
+            break;
+        }
+        case 'ARG': {
+            let argInstruction = instruction.type;
+
+            argInstruction += ` ${instruction.name}`;
+
+            if (instruction.defaultValue) {
+                argInstruction += `=${instruction.defaultValue}`;
+            }
+
+            dockerFileInstructions.push(argInstruction);
+            break;
+        }
+        case 'RUN':
+        case 'ENTRYPOINT':
+        case 'CMD': {
+            let cmdInstruction = instruction.type;
+
+            if (typeof instruction.command === 'string') {
+                cmdInstruction += ` ${instruction.command}`;
+            } else if (Array.isArray(instruction.command) && instruction.command.every((c) => typeof c === 'string')) {
+                cmdInstruction += ` ["${instruction.command.join('", "')}"]`;
+            } else {
+                throw new Error(`Unknown command type, it must be string or array of strings! ${instruction.command}`);
+            }
+
+            dockerFileInstructions.push(cmdInstruction);
+            break;
+        }
+
+        case 'COMMENT': {
+            const commentInstruction = `# ${instruction.comment}`;
+
+            dockerFileInstructions.push(commentInstruction);
+            break;
+        }
+        case 'ENV': {
+            let envInstruction = instruction.type;
+
+            envInstruction += ` ${instruction.name}="${instruction.value}"`;
+
+            dockerFileInstructions.push(envInstruction);
+            break;
+        }
+        case 'EXPOSE': {
+            let exposeInstruction = instruction.type;
+
+            if (instruction.protocol) {
+                exposeInstruction += ` ${instruction.port}/${instruction.protocol}`;
+            } else {
+                exposeInstruction += ` ${instruction.port}`;
+            }
+
+            dockerFileInstructions.push(exposeInstruction);
+            break;
+        }
+        case 'FROM': {
+            let fromInstruction = instruction.type;
+
+            if (instruction.platform) {
+                fromInstruction += ` --platform=${instruction.platform}`;
+            }
+
+            fromInstruction += ` ${instruction.image}:${instruction.tag || 'latest'}`;
+
+            if (instruction.name) {
+                fromInstruction += ` AS ${instruction.name}`;
+            }
+
+            dockerFileInstructions.push(fromInstruction);
+            break;
+        }
+        case 'HEALTHCHECK': {
+            let healthCheckInstruction = instruction.type;
+
+            if (instruction.interval) {
+                healthCheckInstruction += ` --interval=${instruction.interval}`;
+            }
+
+            if (instruction.retries) {
+                healthCheckInstruction += ` --retries=${instruction.retries}`;
+            }
+
+            if (instruction.startPeriod) {
+                healthCheckInstruction += ` --start-period=${instruction.startPeriod}`;
+            }
+
+            if (instruction.timeout) {
+                healthCheckInstruction += ` --timeout=${instruction.timeout}`;
+            }
+
+            healthCheckInstruction += ` ${instruction.command}`;
+
+            dockerFileInstructions.push(healthCheckInstruction);
+            break;
+        }
+        case 'LABEL': {
+            Object.entries(instruction.labels).forEach(([name, value]) => {
+                let labelInstruction = instruction.type;
+                labelInstruction += ` "${name}"="${value}"`;
+                dockerFileInstructions.push(labelInstruction);
+            });
+            break;
+        }
+        case 'ONBUILD': {
+            let onBuildInstruction = instruction.type;
+
+            onBuildInstruction += ` ${instruction.instruction}`;
+
+            dockerFileInstructions.push(onBuildInstruction);
+            break;
+        }
+        case 'SHELL': {
+            let shellInstruction = instruction.type;
+
+            shellInstruction += ` ["${instruction.exec.join('", "')}"]`;
+
+            dockerFileInstructions.push(shellInstruction);
+            break;
+        }
+        case 'STOPSIGNAL': {
+            let stopSignalInstruction = instruction.type;
+
+            stopSignalInstruction += ` ${instruction.signal}`;
+
+            dockerFileInstructions.push(stopSignalInstruction);
+            break;
+        }
+        case 'USER': {
+            let userInstruction = instruction.type;
+
+            userInstruction += ` ${instruction.user}`;
+
+            dockerFileInstructions.push(userInstruction);
+            break;
+        }
+        case 'VOLUME': {
+            let volumeInstruction = instruction.type;
+
+            if (typeof instruction.volume === 'string') {
+                volumeInstruction += ` ${instruction.volume}`;
+            } else if (Array.isArray(instruction.volume) && instruction.volume.every((c) => typeof c === 'string')) {
+                volumeInstruction += ` ["${instruction.volume.join('", "')}"]`;
+            } else {
+                throw new Error(`Unknown volume type, it must be string or array of strings! ${instruction.volume}`);
+            }
+
+            dockerFileInstructions.push(volumeInstruction);
+            break;
+        }
+        case 'WORKDIR': {
+            const workDirInstruction = `${instruction.type} ${instruction.workdir}`;
+
+            dockerFileInstructions.push(workDirInstruction);
+            break;
+        }
+        default: {
+            throw new Error(`I don't know instruction with type ${instruction.type}`);
+        }
+        }
+    }
+
+    return dockerFileInstructions.join('\n');
+};
+
+module.exports = {
+    buildInstructions
+};