@scandipwa/magento-scripts 2.0.3 → 2.0.5

package/lib/tasks/docker/image/image-api.d.ts

@@ -1,4 +1,4 @@
-import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command'
 
 export interface ImagesLsOptions<T extends boolean = false> {
     all?: boolean
@@ -46,12 +46,11 @@ export interface ImagesInspectResult {
     Parent: string
     Comment: string
     Created: string
-    Container: string
     ContainerConfig: unknown
     DockerVersion: string
     Author: string
     Config: {
-        Env: string[],
+        Env: string[]
         Cmd: string[]
         WorkingDir: string
         Entrypoint: string[]

package/lib/tasks/docker/image/image-api.js

@@ -1,4 +1,4 @@
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
 
 /**
  * @param {import('./image-api').ImagesLsOptions} options
@@ -13,18 +13,23 @@ const ls = async (options, execOptions = {}) => {
         noTrunc,
         quiet,
         digests
-    } = options;
+    } = options
 
-    const allArg = all && '--all';
-    const filterArg = filter && typeof filter === 'string'
-        ? `--filter=${filter}`
-        : filter && Array.isArray(filter) && filter.every((f) => typeof f === 'string') && filter.map((f) => `--filter=${f}`).join(' ');
-    const formatArg = !formatToJSON && format
-        ? `--format=${format}`
-        : formatToJSON && '--format=\'{{json .}}\'';
-    const digestsArg = digests && '--digests';
-    const noTruncArg = noTrunc && '--no-trunc';
-    const quietArg = quiet && '--quiet';
+    const allArg = all && '--all'
+    const filterArg =
+        filter && typeof filter === 'string'
+            ? `--filter=${filter}`
+            : filter &&
+              Array.isArray(filter) &&
+              filter.every((f) => typeof f === 'string') &&
+              filter.map((f) => `--filter=${f}`).join(' ')
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
+    const digestsArg = digests && '--digests'
+    const noTruncArg = noTrunc && '--no-trunc'
+    const quietArg = quiet && '--quiet'
 
     const args = [
         allArg,
@@ -33,45 +38,47 @@ const ls = async (options, execOptions = {}) => {
         digestsArg,
         noTruncArg,
         quietArg
-    ].filter(Boolean).join(' ');
+    ]
+        .filter(Boolean)
+        .join(' ')
 
     if (formatToJSON) {
-        const result = await execAsyncSpawn(`docker image ls ${args}`, execOptions);
-        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+        const result = await execAsyncSpawn(
+            `docker image ls ${args}`,
+            execOptions
+        )
+        return JSON.parse(`[${result.split('\n').join(', ')}]`)
     }
 
-    return execAsyncSpawn(`docker image ls ${args}`, execOptions);
-};
+    return execAsyncSpawn(`docker image ls ${args}`, execOptions)
+}
 
 /**
  * @param {import('./image-api').ImagesInspectOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
 const inspect = async (options, execOptions = {}) => {
-    const {
-        image,
-        format,
-        formatToJSON = false
-    } = options;
+    const { image, format, formatToJSON = false } = options
 
-    const formatArg = !formatToJSON && format
-        ? `--format=${format}`
-        : formatToJSON && '--format=\'{{json .}}\'';
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
 
-    const args = [
-        formatArg,
-        image
-    ].filter(Boolean).join(' ');
+    const args = [formatArg, image].filter(Boolean).join(' ')
 
     if (formatToJSON) {
-        const result = await execAsyncSpawn(`docker image inspect ${args}`, execOptions);
-        return JSON.parse(result);
+        const result = await execAsyncSpawn(
+            `docker image inspect ${args}`,
+            execOptions
+        )
+        return JSON.parse(result)
     }
 
-    return execAsyncSpawn(`docker image inspect ${args}`, execOptions);
-};
+    return execAsyncSpawn(`docker image inspect ${args}`, execOptions)
+}
 
 module.exports = {
     ls,
     inspect
-};
+}

package/lib/tasks/docker/image/index.js

@@ -1,5 +1,5 @@
-const imageApi = require('./image-api');
+const imageApi = require('./image-api')
 
 module.exports = {
     imageApi
-};
+}

package/lib/tasks/docker/index.js

@@ -1,36 +1,41 @@
-const containers = require('./containers');
-const network = require('./network');
-const volume = require('./volume');
-const dockerApi = require('./api');
+const containers = require('./containers')
+const network = require('./network')
+const volume = require('./volume')
+const dockerApi = require('./api')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const startServices = () => ({
     title: 'Starting Docker services',
-    task: (ctx, task) => task.newListr([
-        containers.startContainers(),
-        containers.checkContainersAreRunning()
-    ], {
-        concurrent: false,
-        exitOnError: true
-    })
-});
+    task: (ctx, task) =>
+        task.newListr(
+            [
+                containers.startContainers(),
+                containers.checkContainersAreRunning()
+            ],
+            {
+                concurrent: false,
+                exitOnError: true
+            }
+        )
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const stopServices = () => ({
     title: 'Stopping Docker services',
-    task: (ctx, task) => task.newListr([
-        containers.stopContainers(),
-        volume.removeLocalVolumes(),
-        network.tasks.removeNetwork()
-    ])
-});
+    task: (ctx, task) =>
+        task.newListr([
+            containers.stopContainers(),
+            volume.removeLocalVolumes(),
+            network.tasks.removeNetwork()
+        ])
+})
 
 module.exports = {
     startServices,
     stopServices,
     dockerApi
-};
+}

package/lib/tasks/docker/network/index.js

@@ -1,7 +1,7 @@
-const networkApi = require('./network-api');
-const tasks = require('./tasks');
+const networkApi = require('./network-api')
+const tasks = require('./tasks')
 
 module.exports = {
     networkApi,
     tasks
-};
+}

package/lib/tasks/docker/network/network-api.d.ts

@@ -1,4 +1,4 @@
-import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command'
 
 export interface NetworkLsOptions<T extends boolean = false> {
     filter?: string | string[]
@@ -56,13 +56,16 @@ export interface NetworkInspectResult {
         Network: string
     }
     ConfigOnly: boolean
-    Containers: Record<string, {
-        Name: string
-        EndpointID: string
-        MacAddress: string
-        IPv4Address: string
-        IPv6Address: string
-    }>
+    Containers: Record<
+        string,
+        {
+            Name: string
+            EndpointID: string
+            MacAddress: string
+            IPv4Address: string
+            IPv6Address: string
+        }
+    >
     Options: Record<string, unknown>
     Labels: Record<string, unknown>
 }

package/lib/tasks/docker/network/network-api.js

@@ -1,99 +1,91 @@
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
 
 /**
  * @param {import('./network-api').NetworkLsOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
 const ls = async (options, execOptions = {}) => {
-    const {
-        filter,
-        format,
-        formatToJSON = false,
-        noTrunc,
-        quiet
-    } = options;
+    const { filter, format, formatToJSON = false, noTrunc, quiet } = options
 
-    const formatArg = !formatToJSON && format
-        ? `--format=${format}`
-        : formatToJSON && '--format=\'{{json .}}\'';
-    const filterArg = filter && typeof filter === 'string'
-        ? `--filter=${filter}`
-        : filter && Array.isArray(filter) && filter.every((f) => typeof f === 'string') && filter.map((f) => `--filter=${f}`).join(' ');
-    const noTruncArg = noTrunc && '--no-trunc';
-    const quietArg = quiet && '--quiet';
-    const args = [
-        filterArg,
-        formatArg,
-        noTruncArg,
-        quietArg
-    ].filter(Boolean).join(' ');
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
+    const filterArg =
+        filter && typeof filter === 'string'
+            ? `--filter=${filter}`
+            : filter &&
+              Array.isArray(filter) &&
+              filter.every((f) => typeof f === 'string') &&
+              filter.map((f) => `--filter=${f}`).join(' ')
+    const noTruncArg = noTrunc && '--no-trunc'
+    const quietArg = quiet && '--quiet'
+    const args = [filterArg, formatArg, noTruncArg, quietArg]
+        .filter(Boolean)
+        .join(' ')
 
     if (formatToJSON) {
-        const result = await execAsyncSpawn(`docker network ls ${args}`, execOptions);
-        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+        const result = await execAsyncSpawn(
+            `docker network ls ${args}`,
+            execOptions
+        )
+        return JSON.parse(`[${result.split('\n').join(', ')}]`)
     }
 
-    return execAsyncSpawn(`docker network ls ${args}`, execOptions);
-};
+    return execAsyncSpawn(`docker network ls ${args}`, execOptions)
+}
 
 /**
  * @param {import('./network-api').NetworkInspectOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
 const inspect = async (options, execOptions = {}) => {
-    const {
-        network,
-        format,
-        formatToJSON = false,
-        verbose
-    } = options;
+    const { network, format, formatToJSON = false, verbose } = options
 
-    const formatArg = !formatToJSON && format
-        ? `--format=${format}`
-        : formatToJSON && '--format=\'{{json .}}\'';
-    const verboseArg = verbose && '--verbose';
-    const networks = typeof network === 'string'
-        ? network
-        : network.join(' ');
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
+    const verboseArg = verbose && '--verbose'
+    const networks = typeof network === 'string' ? network : network.join(' ')
 
-    const args = [
-        formatArg,
-        verboseArg
-    ].filter(Boolean).join(' ');
+    const args = [formatArg, verboseArg].filter(Boolean).join(' ')
 
     if (formatToJSON) {
-        const result = await execAsyncSpawn(`docker network inspect ${args} ${networks}`, execOptions);
-        return JSON.parse(result);
+        const result = await execAsyncSpawn(
+            `docker network inspect ${args} ${networks}`,
+            execOptions
+        )
+        return JSON.parse(result)
     }
 
-    return execAsyncSpawn(`docker network inspect ${args} ${networks}`, execOptions);
-};
+    return execAsyncSpawn(
+        `docker network inspect ${args} ${networks}`,
+        execOptions
+    )
+}
 
 /**
  * @param {import('./network-api').NetworkCreateOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
 const create = async (options, execOptions = {}) => {
-    const {
-        network,
-        driver
-    } = options;
+    const { network, driver } = options
 
-    const networks = typeof network === 'string'
-        ? network
-        : network.join(' ');
+    const networks = typeof network === 'string' ? network : network.join(' ')
 
-    const driverArg = driver && `--driver='${ driver }'`;
+    const driverArg = driver && `--driver='${driver}'`
 
-    const args = [
-        driverArg
-    ].filter(Boolean).join(' ');
+    const args = [driverArg].filter(Boolean).join(' ')
 
-    return execAsyncSpawn(`docker network create ${args} ${networks}`, execOptions);
-};
+    return execAsyncSpawn(
+        `docker network create ${args} ${networks}`,
+        execOptions
+    )
+}
 
 module.exports = {
     ls,
     inspect,
     create
-};
+}

package/lib/tasks/docker/network/tasks.js

@@ -1,82 +1,92 @@
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const KnownError = require('../../../errors/known-error');
-const UnknownError = require('../../../errors/unknown-error');
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
-const networkApi = require('./network-api');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const KnownError = require('../../../errors/known-error')
+const UnknownError = require('../../../errors/unknown-error')
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
+const networkApi = require('./network-api')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const pruneNetworks = () => ({
     title: 'Removing custom networks not used by at least one container',
     task: () => execAsyncSpawn('docker network prune -f')
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const createNetwork = () => ({
     title: 'Deploying Docker network',
     task: async ({ config: { docker } }, task) => {
-        const networkList = await networkApi.ls({ formatToJSON: true });
+        const networkList = await networkApi.ls({ formatToJSON: true })
 
-        if (networkList.some((network) => network.Name === docker.network.name)) {
-            task.skip();
-            return;
+        if (
+            networkList.some((network) => network.Name === docker.network.name)
+        ) {
+            task.skip()
+            return
         }
         try {
             await networkApi.create({
                 network: docker.network.name,
                 driver: 'bridge'
-            });
+            })
         } catch (e) {
-            if (e.message.includes('could not find an available, non-overlapping IPv4 address pool')) {
+            if (
+                e.message.includes(
+                    'could not find an available, non-overlapping IPv4 address pool'
+                )
+            ) {
                 const doPruneNetworks = await task.prompt({
                     type: 'Confirm',
                     message: `You don't have available, non-overlapping IPv4 address pool on you system.
 Do you want remove all custom networks not used by at least one container?`
-                });
+                })
 
                 if (doPruneNetworks) {
                     return task.newListr([
                         pruneNetworks(),
                         {
-                            task: () => networkApi.create({
-                                network: docker.network.name,
-                                driver: 'bridge'
-                            })
-                        }]);
+                            task: () =>
+                                networkApi.create({
+                                    network: docker.network.name,
+                                    driver: 'bridge'
+                                })
+                        }
+                    ])
                 }
 
                 throw new KnownError(`Unable to create network for your project.
 You need to delete unused networks yourself.
-Use command ${logger.style.command('docker network prune')}`);
+Use command ${logger.style.command('docker network prune')}`)
             }
 
-            throw new UnknownError(`Unable to create network!\n\n${e}`);
+            throw new UnknownError(`Unable to create network!\n\n${e}`)
         }
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const removeNetwork = () => ({
     title: 'Removing Docker network',
     task: async ({ config: { docker } }, task) => {
-        const networkList = await networkApi.ls({ formatToJSON: true });
+        const networkList = await networkApi.ls({ formatToJSON: true })
 
-        if (!networkList.some((network) => network.Name === docker.network.name)) {
-            task.skip();
-            return;
+        if (
+            !networkList.some((network) => network.Name === docker.network.name)
+        ) {
+            task.skip()
+            return
         }
 
-        await execAsyncSpawn(`docker network rm ${ docker.network.name }`);
+        await execAsyncSpawn(`docker network rm ${docker.network.name}`)
     }
-});
+})
 
 module.exports = {
     createNetwork,
     removeNetwork,
     pruneNetworks
-};
+}