@scandipwa/magento-scripts 2.0.3-alpha.0 → 2.0.4

package/lib/util/set-config.js

@@ -1,35 +1,44 @@
-const eta = require('eta');
-const fs = require('fs');
-const path = require('path');
-const pathExists = require('./path-exists');
+const eta = require('eta')
+const fs = require('fs')
+const path = require('path')
+const pathExists = require('./path-exists')
 
+/**
+ * @param {{ configPathname: string, template: string, overwrite?: boolean, templateArgs?: Record<string, unknown> }} param0
+ */
 const setConfigFile = async ({
     configPathname,
     template,
     overwrite,
     templateArgs = {}
 }) => {
-    const pathOk = await pathExists(configPathname);
+    const pathOk = await pathExists(configPathname)
 
     if (pathOk && !overwrite) {
-        return true;
+        return true
     }
 
-    const configTemplate = await fs.promises.readFile(template, 'utf-8');
+    const configTemplate = await fs.promises.readFile(template, 'utf-8')
     const compliedConfig = await eta.render(configTemplate, {
         date: new Date().toUTCString(),
         ...templateArgs
-    });
+    })
 
-    const { dir } = path.parse(configPathname);
+    if (!compliedConfig) {
+        return false
+    }
+
+    const { dir } = path.parse(configPathname)
 
-    const dirExists = await pathExists(dir);
+    const dirExists = await pathExists(dir)
     if (!dirExists) {
-        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true })
     }
-    await fs.promises.writeFile(configPathname, compliedConfig, { encoding: 'utf-8' });
+    await fs.promises.writeFile(configPathname, compliedConfig, {
+        encoding: 'utf-8'
+    })
 
-    return true;
-};
+    return true
+}
 
-module.exports = setConfigFile;
+module.exports = setConfigFile

package/lib/util/sleep.js

@@ -1,3 +1,8 @@
-const sleep = (timeout) => new Promise((resolve) => setTimeout(resolve, timeout));
+/**
+ * @param {number} timeout
+ * @returns {Promise<void>}
+ */
+const sleep = (timeout) =>
+    new Promise((resolve) => setTimeout(resolve, timeout))
 
-module.exports = sleep;
+module.exports = sleep

package/lib/util/systemctl.js

@@ -1,95 +1,113 @@
-const { execAsyncSpawn } = require('./exec-async-command');
+const { execAsyncSpawn } = require('./exec-async-command')
 
 /**
- * @param {String} cmd
- * @param {String} serviceName
- * @param {{ now: boolean, user: boolean }} options
+ * @param {string} cmd
+ * @param {string} [serviceName]
+ * @param {{ now?: boolean, user?: boolean }} options
  */
-const run = (cmd, serviceName, options = {}) => execAsyncSpawn(
-    `systemctl ${ options.user ? '--user ' : '' }${ cmd }${ serviceName ? ` ${ serviceName }` : '' }${ options.now ? ' --now' : ''}`,
-    {
-        withCode: true
-    }
-);
+const run = (cmd, serviceName, options = {}) =>
+    execAsyncSpawn(
+        `systemctl ${options.user ? '--user ' : ''}${cmd}${
+            serviceName ? ` ${serviceName}` : ''
+        }${options.now ? ' --now' : ''}`,
+        {
+            withCode: true
+        }
+    )
 
-const daemonReload = () => run('daemon-reload');
+const daemonReload = () => run('daemon-reload')
 
 /**
  * @param {String} serviceName
- * @param {{ now: boolean, user: boolean }} defaultOptions
+ * @param {{ now?: boolean, user?: boolean }} [defaultOptions]
  */
 const systemctlControl = (serviceName, defaultOptions = {}) => ({
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    disable: (options = {}) => run('disable', serviceName, { ...defaultOptions, ...options }),
+    disable: (options = {}) =>
+        run('disable', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    enable: (options = {}) => run('enable', serviceName, { ...defaultOptions, ...options }),
+    enable: (options = {}) =>
+        run('enable', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    enableAndStart: (options = {}) => run('enable', serviceName, { now: true, ...defaultOptions, ...options }),
+    enableAndStart: (options = {}) =>
+        run('enable', serviceName, {
+            now: true,
+            ...defaultOptions,
+            ...options
+        }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    restart: (options = {}) => run('restart', serviceName, { ...defaultOptions, ...options }),
+    restart: (options = {}) =>
+        run('restart', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    start: (options = {}) => run('start', serviceName, { ...defaultOptions, ...options }),
+    start: (options = {}) =>
+        run('start', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    stop: (options = {}) => run('stop', serviceName, { ...defaultOptions, ...options }),
+    stop: (options = {}) =>
+        run('stop', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
     isEnabled: async (options = {}) => {
         try {
-            const { result } = await run('is-enabled', serviceName, { ...defaultOptions, ...options });
-            return result.includes('enabled');
+            const { result } = await run('is-enabled', serviceName, {
+                ...defaultOptions,
+                ...options
+            })
+            return result.includes('enabled')
         } catch (e) {
-            return false;
+            return false
         }
     },
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
     isRunning: async (options = {}) => {
         try {
-            const { result } = await run('status', serviceName, { ...defaultOptions, ...options });
+            const { result } = await run('status', serviceName, {
+                ...defaultOptions,
+                ...options
+            })
 
-            return result.includes('active (running)');
+            return result.includes('active (running)')
         } catch (e) {
-            return false;
+            return false
         }
     },
     /**
-     * @param {{ user: boolean }} options
+     * @param {{ user?: boolean }} [options]
      */
     exists: async (options = {}) => {
-        const optionsToUse = { ...defaultOptions, ...options };
+        const optionsToUse = { ...defaultOptions, ...options }
         try {
-            // eslint-disable-next-line max-len, no-useless-escape
-            const command = `if [[ $(systemctl ${ optionsToUse.user ? '--user ' : ''}list-units --all -t service --full --no-legend "${ serviceName }.service" | sed 's/^\\s*//g' | cut -f1 -d' ') == ${ serviceName }.service ]]; then
+            const command = `if [[ $(systemctl ${
+                optionsToUse.user ? '--user ' : ''
+            }list-units --all -t service --full --no-legend "${serviceName}.service" | sed 's/^\\s*//g' | cut -f1 -d' ') == ${serviceName}.service ]]; then
                 echo "1"
             else
                 echo "0"
-            fi`;
-            const result = await execAsyncSpawn(
-                command
-            );
+            fi`
+            const result = await execAsyncSpawn(command)
 
-            return result === '1';
+            return result === '1'
         } catch (e) {
-            return false;
+            return false
         }
     }
-});
+})
 
 module.exports = {
     systemctlControl,
     daemonReload
-};
+}

package/lib/util/wait-for-it.js

@@ -1,46 +1,55 @@
-const net = require('net');
-const UnknownError = require('../errors/unknown-error');
-const sleep = require('./sleep');
+const net = require('net')
+const UnknownError = require('../errors/unknown-error')
+const sleep = require('./sleep')
 
-const connectToHostPort = ({ host, port }) => new Promise((resolve, reject) => {
-    const socket = net.createConnection({ host, port, timeout: 15 * 1000 });
+/**
+ * @param {{ host: string, port: number}} param0
+ * @returns {Promise<void>}
+ */
+const connectToHostPort = ({ host, port }) =>
+    new Promise((resolve, reject) => {
+        const socket = net.createConnection({ host, port, timeout: 15 * 1000 })
 
-    socket.on('connect', () => {
-        socket.end();
-        resolve();
-    });
-    socket.on('error', (err) => {
-        socket.end();
-        reject(err);
-    });
-    socket.on('timeout', () => {
-        socket.end();
-        reject(new UnknownError('Connection timeout'));
-    });
-});
+        socket.on('connect', () => {
+            socket.end()
+            resolve()
+        })
+        socket.on('error', (err) => {
+            socket.end()
+            reject(err)
+        })
+        socket.on('timeout', () => {
+            socket.end()
+            reject(new UnknownError('Connection timeout'))
+        })
+    })
 
-const waitForIt = async ({
-    name, host, port, output
-}) => {
-    const startTime = Date.now();
-    let connected = false;
-    output(`Waiting for ${name} at ${host}:${port}...`);
+/**
+ * @param {{ name: string, host: string, port: number, output: (arg: string) => void }} param0
+ */
+const waitForIt = async ({ name, host, port, output }) => {
+    const startTime = Date.now()
+    let connected = false
+    output(`Waiting for ${name} at ${host}:${port}...`)
     while (!connected) {
         try {
-            // eslint-disable-next-line no-await-in-loop
             await Promise.race([
                 sleep(300).then(() => {
-                    throw new UnknownError('Connection timeout');
+                    throw new UnknownError('Connection timeout')
                 }),
                 connectToHostPort({ host, port })
-            ]);
-            connected = true;
-        // eslint-disable-next-line no-empty
+            ])
+            connected = true
         } catch {}
     }
 
-    const endTime = Date.now();
-    output(`${name} at ${host}:${port} is available after ${((endTime - startTime) / 1000).toFixed(0)} seconds`, 3);
-};
+    const endTime = Date.now()
+    output(
+        `${name} at ${host}:${port} is available after ${(
+            (endTime - startTime) /
+            1000
+        ).toFixed(0)} seconds`
+    )
+}
 
-module.exports = waitForIt;
+module.exports = waitForIt

package/lib/util/wait-for-logs.js

@@ -1,41 +1,48 @@
-const { execAsyncSpawn } = require('./exec-async-command');
-const sleep = require('./sleep');
+const { execAsyncSpawn } = require('./exec-async-command')
+const sleep = require('./sleep')
 
-// eslint-disable-next-line no-async-promise-executor
-const waitForLogs = ({ containerName, timeout = 30 * 1000, matchText }) => new Promise(async (resolve, reject) => {
-    let matched = false;
-    let timeoutExceeded = false;
-    await Promise.race([
-        (async () => {
-            while (!timeoutExceeded && !matched) {
-                // eslint-disable-next-line no-await-in-loop
-                const { result } = await execAsyncSpawn(`docker logs ${containerName}`, {
-                    withCode: true
-                });
+/**
+ * @param {{ containerName: string, timeout?: number, matchText: string }} param0
+ * @returns {Promise<void>}
+ */
+const waitForLogs = ({ containerName, timeout = 30 * 1000, matchText }) =>
+    // eslint-disable-next-line no-async-promise-executor
+    new Promise(async (resolve, reject) => {
+        let matched = false
+        let timeoutExceeded = false
+        await Promise.race([
+            (async () => {
+                // eslint-disable-next-line no-unmodified-loop-condition
+                while (!timeoutExceeded && !matched) {
+                    const { result } = await execAsyncSpawn(
+                        `docker logs ${containerName}`,
+                        {
+                            withCode: true
+                        }
+                    )
 
-                if (matched) {
-                    return;
-                }
-                // eslint-disable-next-line no-loop-func
-                result.split('\n').forEach((line) => {
-                    if (line.includes(matchText)) {
-                        matched = true;
-                        resolve();
+                    if (matched) {
+                        return
                     }
-                });
 
-                // eslint-disable-next-line no-await-in-loop
-                await sleep(500);
-            }
-        })(),
-        sleep(timeout).then(() => {
-            timeoutExceeded = true;
-        })
-    ]);
+                    result.split('\n').forEach((line) => {
+                        if (line.includes(matchText)) {
+                            matched = true
+                            resolve()
+                        }
+                    })
+
+                    await sleep(500)
+                }
+            })(),
+            sleep(timeout).then(() => {
+                timeoutExceeded = true
+            })
+        ])
 
-    if (timeoutExceeded) {
-        reject(new Error('Timeout exception'));
-    }
-});
+        if (timeoutExceeded) {
+            reject(new Error('Timeout exception'))
+        }
+    })
 
-module.exports = waitForLogs;
+module.exports = waitForLogs

package/lib/util/xdg-open-exists.js

@@ -1,27 +1,27 @@
-const fs = require('fs');
-const pathExists = require('./path-exists');
+const fs = require('fs')
+const pathExists = require('./path-exists')
 
 const checkForXDGOpen = async () => {
-    const pathParts = process.env.PATH.split(':');
+    const pathParts = process.env.PATH.split(':')
 
     const results = await Promise.all(
-        pathParts.map(
-            async (pathPart) => {
-                if (!await pathExists(pathPart)) {
-                    return false;
-                }
+        pathParts.map(async (pathPart) => {
+            if (!(await pathExists(pathPart))) {
+                return false
+            }
 
-                const files = await fs.promises.readdir(pathPart, {
-                    encoding: 'utf-8',
-                    withFileTypes: true
-                });
+            const files = await fs.promises.readdir(pathPart, {
+                encoding: 'utf-8',
+                withFileTypes: true
+            })
 
-                return files.some((file) => file.isFile() && file.name === 'xdg-open');
-            }
-        )
-    );
+            return files.some(
+                (file) => file.isFile() && file.name === 'xdg-open'
+            )
+        })
+    )
 
-    return results.includes(true);
-};
+    return results.includes(true)
+}
 
-module.exports = checkForXDGOpen;
+module.exports = checkForXDGOpen

package/package.json

@@ -3,7 +3,7 @@
     "description": "Scripts and configuration used by CMA.",
     "homepage": "https://docs.create-magento-app.com/",
     "repository": "github:scandipwa/create-magento-app",
-    "version": "2.0.3-alpha.0",
+    "version": "2.0.4",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -23,7 +23,8 @@
         "arm64"
     ],
     "dependencies": {
-        "@scandipwa/scandipwa-dev-utils": "0.1.13",
+        "@scandipwa/scandipwa-dev-utils": "0.1.16",
+        "@tilework/mosaic-dev-utils": "^0.2.3",
         "conf": "10.1.2",
         "enquirer": "2.3.6",
         "eta": "1.12.3",
@@ -54,5 +55,8 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "c9e600b48c4f6d2dd612d234aaf839f8cbcf1734"
+    "devDependencies": {
+        "@types/yargs": "^17.0.13"
+    },
+    "gitHead": "0938871489021e7a165a42b24d45775107a32870"
 }

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "checkJs": true,
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "module": "CommonJS",
+        "lib": ["ES2022"],
+        "target": "ES2022",
+        "moduleResolution": "Node",
+        "types": [
+            "./typings"
+        ]
+    },
+    "exclude": [
+        "**/node_modules",
+        "./lib/config/templates/**"
+    ],
+    "include": [
+        "./"
+    ]
+}

package/typings/context.d.ts

@@ -1,16 +1,42 @@
-import mysql2 from 'mysql2';
+import * as mysql2 from 'mysql2'
 
-import { ProjectConfig } from '../lib/config/config';
-import { DockerVersionResult } from '../lib/tasks/docker/api';
-import { CMAConfiguration, PHPExtensions } from './index';
-import { PHPStormConfig } from './phpstorm';
+import { ProjectConfig } from '../lib/config/config'
+import { DockerVersionResult } from '../lib/tasks/docker/api'
+import { systemApi } from '../lib/tasks/docker/system'
+import { CMAConfiguration, PHPExtensions } from './index'
+import { PHPStormConfig } from './phpstorm'
 
 export interface ListrContext {
+    noOpen?: boolean
+    skipSetup?: boolean
+    resetGlobalConfig?: boolean
+    withCustomersData?: boolean
+    force?: boolean
+    magentoFirstInstall?: boolean
+    encryptionKey?: string
+    pullImages?: boolean
+    throwMagentoVersionMissing: boolean
+    projectPath: string
+    systemDFData?: systemApi.SystemDFResult
+    debug: boolean
+    verbose: boolean
     magentoVersion: string
     composerVersion: string
     phpVersion: string
     port?: number
-    ports?: {
+    ports: {
+        app: number
+        fpm: number
+        xdebug: number
+        mariadb: number
+        redis: number
+        elasticsearch: number
+        varnish: number
+        sslTerminator: number
+        maildevSMTP: number
+        maildevWeb: number
+    }
+    cachedPorts?: {
         app: number
         fpm: number
         xdebug: number
@@ -50,33 +76,39 @@ export interface ListrContext {
             network: {
                 name: string
             }
-            volumes: Record<'mariadb' | 'redis' | 'elasticsearch' | 'nginx' | 'appPub' | 'appSetup', {
-                name: string
-                opt?: {
-                    type: string
-                    device: string
-                    o: string
+            volumes: Record<string,
+                {
+                    name: string,
+                    driver?: string,
+                    opt?: {
+                        mode?: string,
+                        device?: string,
+                        o?: string,
+                        type?: string
+                    }
                 }
-            }>
-            getContainers(): Record<'php' | 'sslTerminator' | 'nginx' | 'redis' | 'mariadb' | 'elasticsearch' | 'varnish', {
-                _: string
-                ports: string[]
-                healthCheck: {
-                    cmd: string
+            >
+            getContainers(ports?: Record<string, number>): Record<string,
+                {
+                    _: string
+                    ports: string[]
+                    healthCheck: {
+                        cmd: string
+                    }
+                    env: Record<string, string>
+                    mountVolumes: string[]
+                    mounts: string[]
+                    restart: string
+                    securityOptions: string[]
+                    network: string
+                    image: string
+                    debugImage?: string
+                    remoteImages?: string[]
+                    name: string
+                    command: string
+                    connectCommand: string[]
                 }
-                env: Record<string, string>
-                mountVolumes: string[]
-                mounts: string[]
-                restart: string
-                securityOptions: string[]
-                network: string
-                image: string
-                debugImage?: string
-                remoteImages?: string[]
-                name: string
-                command: string
-                connectCommand: string[]
-            }>
+            >
         }
         baseConfig: {
             prefix: string
@@ -85,11 +117,21 @@ export interface ListrContext {
             cacheDir: string
             containerMagentoDir: string
         }
-        overridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
-        userConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
-        nonOverridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
+        overridenConfiguration: Required<Omit<
+            CMAConfiguration,
+            'useNonOverlappingPorts'
+        > & { magentoVersion: string }>
+        userConfiguration:  Omit<
+            CMAConfiguration,
+            'useNonOverlappingPorts'
+        >
+        nonOverridenConfiguration:  Required<Omit<
+            CMAConfiguration,
+            'useNonOverlappingPorts'
+        >>
         phpStorm: PHPStormConfig
         projectConfig: ProjectConfig
+        magentoConfiguration: CMAConfiguration['magento']
     }
     systemConfiguration: {
         analytics: boolean