@scandipwa/magento-scripts 2.0.3 → 2.0.5

package/lib/util/database.js

@@ -1,82 +1,105 @@
 /**
  * Update table in **magento** database
  * @param {String} table Table name
- * @param {{path: string, value: string}[]} values
- * @param {import('../../typings/context').ListrContext} param1
+ * @param {{ path: string, value: string | number | null }[]} values
+ * @param {{ databaseConnection: import('../../typings/context').ListrContext['databaseConnection'], task: import('listr2').ListrTaskWrapper<import('../../typings/context').ListrContext, any> }} param2
  */
-const updateTableValues = async (table, values, { databaseConnection, task }) => {
+const updateTableValues = async (
+    table,
+    values,
+    { databaseConnection, task }
+) => {
     const [rows] = await databaseConnection.query(`
         SELECT * FROM ${table}
         WHERE ${values.map((p) => `path = '${p.path}'`).join(' OR ')};
-    `);
+    `)
 
     if (rows.filter(Boolean).length !== values.length) {
-        const lostConfigs = values.filter((p) => !rows.some((row) => row.path === p.path));
+        const lostConfigs = values.filter(
+            (p) => !rows.some((row) => row.path === p.path)
+        )
         for (const config of lostConfigs) {
-            await databaseConnection.query(`
+            await databaseConnection.query(
+                `
                 INSERT INTO ${table}
                 (scope, path, value)
                 VALUES ('default', ?, ?);
-            `, [config.path, config.value]);
+            `,
+                [config.path, config.value]
+            )
         }
 
-        const configsToUpdate = values.filter((p) => rows.some((row) => row.path === p.path));
+        const configsToUpdate = values.filter((p) =>
+            rows.some((row) => row.path === p.path)
+        )
         for (const config of configsToUpdate) {
-            await databaseConnection.query(`
+            await databaseConnection.query(
+                `
                 UPDATE ${table}
                 SET value = ?
                 WHERE path = ?;
-            `, [config.value, config.path]);
+            `,
+                [config.value, config.path]
+            )
         }
 
-        return;
+        return
     }
 
+    /**
+     * @param {{ path: string, value: unknown }} param0
+     */
     const checkIfValueIsCorrect = ({ path, value }) => {
-        const val = values.find((p) => p.path === path);
+        const val = values.find((p) => p.path === path)
 
-        return val && val.value === value;
-    };
+        return val && val.value === value
+    }
 
     if (rows.every(checkIfValueIsCorrect)) {
-        task.skip();
-        return;
+        task.skip()
+        return
     }
 
     const configsToUpdate = values.filter(({ path, value }) => {
-        const row = rows.find((row) => row.path === path);
+        const row = rows.find((row) => row.path === path)
 
-        return row && row.value !== value;
-    });
+        return row && row.value !== value
+    })
 
     for (const config of configsToUpdate) {
-        await databaseConnection.query(`
+        await databaseConnection.query(
+            `
             UPDATE ${table}
             SET value = ?
             WHERE path = ?;
-        `, [config.value, config.path]);
+        `,
+            [config.value, config.path]
+        )
     }
-};
+}
 
 /**
-* @param {String} database
-* @param {String} tableName
-* @param {import('../../typings/context').ListrContext} param2
-*/
+ * @param {String} database
+ * @param {String} tableName
+ * @param {import('../../typings/context').ListrContext} param2
+ */
 const isTableExists = async (database, tableName, { databaseConnection }) => {
     /**
-    * @type {{ tableCount: number }[][]}
-    */
-    const [[{ tableCount }]] = await databaseConnection.query(`
+     * @type {{ tableCount: number }[][]}
+     */
+    const [[{ tableCount }]] = await databaseConnection.query(
+        `
    SELECT count(*) as tableCount
    FROM information_schema.TABLES
    WHERE (TABLE_SCHEMA = ?) AND (TABLE_NAME = ?);
-`, [database, tableName]);
+`,
+        [database, tableName]
+    )
 
-    return tableCount > 0;
-};
+    return tableCount > 0
+}
 
 module.exports = {
     updateTableValues,
     isTableExists
-};
+}

package/lib/util/deepmerge.d.ts

@@ -1 +1 @@
-export function deepmerge<T>(target: T, ...sources: T[]): T
+export function deepmerge<T>(target: T, ...sources: Partial<T>[]): T

package/lib/util/deepmerge.js

@@ -1,37 +1,28 @@
 /**
  * Merge object deeply
- * @param {object} target
- * @param  {...object} sources
- * @returns {object}
+ * @type {<T>(target: T, ...sources: Partial<T>[]) => T}
  */
-function deepmerge(
-    target,
-    ...sources
-) {
-    const targetCopy = { ...target };
-    const isObject = (obj) => obj && typeof obj === 'object';
-    sources.forEach((source) => Object.keys(source).forEach((key) => {
-        const targetValue = targetCopy[key];
-        const sourceValue = source[key];
+function deepmerge(target, ...sources) {
+    const targetCopy = { ...target }
+    const isObject = (obj) => obj && typeof obj === 'object'
+    sources.forEach((source) =>
+        Object.keys(source).forEach((key) => {
+            const targetValue = targetCopy[key]
+            const sourceValue = source[key]
 
-        if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
-            targetCopy[key] = targetValue.concat(sourceValue);
-        } else if (
-            isObject(targetValue)
-          && isObject(sourceValue)
-        ) {
-            targetCopy[key] = deepmerge(
-                { ...targetValue },
-                sourceValue
-            );
-        } else {
-            targetCopy[key] = sourceValue;
-        }
-    }));
+            if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+                targetCopy[key] = targetValue.concat(sourceValue)
+            } else if (isObject(targetValue) && isObject(sourceValue)) {
+                targetCopy[key] = deepmerge({ ...targetValue }, sourceValue)
+            } else {
+                targetCopy[key] = sourceValue
+            }
+        })
+    )
 
-    return targetCopy;
+    return targetCopy
 }
 
 module.exports = {
     deepmerge
-};
+}

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

@@ -6,192 +6,208 @@ const buildInstructions = (instructions) => {
     /**
      * @type {string[]}
      */
-    const dockerFileInstructions = [];
+    const dockerFileInstructions = []
 
     for (const instruction of instructions) {
         switch (instruction.type) {
-        case 'COPY':
-        case 'ADD': {
-            let addInstruction = 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;
+                if (instruction.type === 'COPY' && instruction.from) {
+                    addInstruction += ` --from=${instruction.from}`
+                }
 
-            argInstruction += ` ${instruction.name}`;
+                if (instruction.chown) {
+                    addInstruction += ` --chown=${instruction.chown}`
+                }
 
-            if (instruction.defaultValue) {
-                argInstruction += `=${instruction.defaultValue}`;
-            }
+                addInstruction += ` ${instruction.src.join(' ')}`
+                addInstruction += ` ${instruction.dest}`
 
-            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(addInstruction)
+                break
             }
+            case 'ARG': {
+                let argInstruction = instruction.type
 
-            dockerFileInstructions.push(cmdInstruction);
-            break;
-        }
+                argInstruction += ` ${instruction.name}`
 
-        case 'COMMENT': {
-            const commentInstruction = `# ${instruction.comment}`;
+                if (instruction.defaultValue) {
+                    argInstruction += `=${instruction.defaultValue}`
+                }
 
-            dockerFileInstructions.push(commentInstruction);
-            break;
-        }
-        case 'ENV': {
-            let envInstruction = instruction.type;
-
-            envInstruction += ` ${instruction.name}="${instruction.value}"`;
+                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
+            }
 
-            dockerFileInstructions.push(envInstruction);
-            break;
-        }
-        case 'EXPOSE': {
-            let exposeInstruction = instruction.type;
+            case 'COMMENT': {
+                const commentInstruction = `# ${instruction.comment}`
 
-            if (instruction.protocol) {
-                exposeInstruction += ` ${instruction.port}/${instruction.protocol}`;
-            } else {
-                exposeInstruction += ` ${instruction.port}`;
+                dockerFileInstructions.push(commentInstruction)
+                break
             }
+            case 'ENV': {
+                let envInstruction = instruction.type
 
-            dockerFileInstructions.push(exposeInstruction);
-            break;
-        }
-        case 'FROM': {
-            let fromInstruction = instruction.type;
+                envInstruction += ` ${instruction.name}="${instruction.value}"`
 
-            if (instruction.platform) {
-                fromInstruction += ` --platform=${instruction.platform}`;
+                dockerFileInstructions.push(envInstruction)
+                break
             }
+            case 'EXPOSE': {
+                let exposeInstruction = instruction.type
 
-            fromInstruction += ` ${instruction.image}:${instruction.tag || 'latest'}`;
+                if (instruction.protocol) {
+                    exposeInstruction += ` ${instruction.port}/${instruction.protocol}`
+                } else {
+                    exposeInstruction += ` ${instruction.port}`
+                }
 
-            if (instruction.name) {
-                fromInstruction += ` AS ${instruction.name}`;
+                dockerFileInstructions.push(exposeInstruction)
+                break
             }
+            case 'FROM': {
+                let fromInstruction = instruction.type
 
-            dockerFileInstructions.push(fromInstruction);
-            break;
-        }
-        case 'HEALTHCHECK': {
-            let healthCheckInstruction = instruction.type;
+                if (instruction.platform) {
+                    fromInstruction += ` --platform=${instruction.platform}`
+                }
 
-            if (instruction.interval) {
-                healthCheckInstruction += ` --interval=${instruction.interval}`;
-            }
+                fromInstruction += ` ${instruction.image}:${
+                    instruction.tag || 'latest'
+                }`
 
-            if (instruction.retries) {
-                healthCheckInstruction += ` --retries=${instruction.retries}`;
-            }
+                if (instruction.name) {
+                    fromInstruction += ` AS ${instruction.name}`
+                }
 
-            if (instruction.startPeriod) {
-                healthCheckInstruction += ` --start-period=${instruction.startPeriod}`;
+                dockerFileInstructions.push(fromInstruction)
+                break
             }
+            case 'HEALTHCHECK': {
+                let healthCheckInstruction = instruction.type
 
-            if (instruction.timeout) {
-                healthCheckInstruction += ` --timeout=${instruction.timeout}`;
-            }
+                if (instruction.interval) {
+                    healthCheckInstruction += ` --interval=${instruction.interval}`
+                }
 
-            healthCheckInstruction += ` ${instruction.command}`;
+                if (instruction.retries) {
+                    healthCheckInstruction += ` --retries=${instruction.retries}`
+                }
 
-            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;
+                if (instruction.startPeriod) {
+                    healthCheckInstruction += ` --start-period=${instruction.startPeriod}`
+                }
 
-            onBuildInstruction += ` ${instruction.instruction}`;
+                if (instruction.timeout) {
+                    healthCheckInstruction += ` --timeout=${instruction.timeout}`
+                }
 
-            dockerFileInstructions.push(onBuildInstruction);
-            break;
-        }
-        case 'SHELL': {
-            let shellInstruction = instruction.type;
+                healthCheckInstruction += ` ${instruction.command}`
 
-            shellInstruction += ` ["${instruction.exec.join('", "')}"]`;
+                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
 
-            dockerFileInstructions.push(shellInstruction);
-            break;
-        }
-        case 'STOPSIGNAL': {
-            let stopSignalInstruction = instruction.type;
+                onBuildInstruction += ` ${instruction.instruction}`
 
-            stopSignalInstruction += ` ${instruction.signal}`;
+                dockerFileInstructions.push(onBuildInstruction)
+                break
+            }
+            case 'SHELL': {
+                let shellInstruction = instruction.type
 
-            dockerFileInstructions.push(stopSignalInstruction);
-            break;
-        }
-        case 'USER': {
-            let userInstruction = instruction.type;
+                shellInstruction += ` ["${instruction.exec.join('", "')}"]`
 
-            userInstruction += ` ${instruction.user}`;
+                dockerFileInstructions.push(shellInstruction)
+                break
+            }
+            case 'STOPSIGNAL': {
+                let stopSignalInstruction = instruction.type
 
-            dockerFileInstructions.push(userInstruction);
-            break;
-        }
-        case 'VOLUME': {
-            let volumeInstruction = instruction.type;
+                stopSignalInstruction += ` ${instruction.signal}`
 
-            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(stopSignalInstruction)
+                break
             }
+            case 'USER': {
+                let userInstruction = instruction.type
 
-            dockerFileInstructions.push(volumeInstruction);
-            break;
-        }
-        case 'WORKDIR': {
-            const workDirInstruction = `${instruction.type} ${instruction.workdir}`;
+                userInstruction += ` ${instruction.user}`
 
-            dockerFileInstructions.push(workDirInstruction);
-            break;
-        }
-        default: {
-            throw new Error(`I don't know instruction with type ${instruction.type}`);
-        }
+                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');
-};
+    return dockerFileInstructions.join('\n')
+}
 
 module.exports = {
     buildInstructions
-};
+}