hereya-cli 0.13.1 → 0.14.0

package/dist/commands/deploy/index.js

@@ -1,19 +1,15 @@
 import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogLevels, ListrLogger } from 'listr2';
 import path from 'node:path';
 import { getBackend } from '../../backend/index.js';
 import { destroyPackage, provisionPackage } from '../../infrastructure/index.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
-import { logEnv } from '../../lib/env-utils.js';
-import { getLogger } from '../../lib/log.js';
 import { getParameterManager } from '../../lib/parameter/index.js';
-import { setDebug } from '../../lib/shell.js';
-import Up from '../up/index.js';
+import { delay, setDebug } from '../../lib/shell.js';
 export default class Deploy extends Command {
     static description = 'Deploy a hereya project using the project deployment package';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         chdir: Flags.string({
             description: 'directory to run command in',
@@ -32,96 +28,263 @@ export default class Deploy extends Command {
     async run() {
         const { flags } = await this.parse(Deploy);
         setDebug(flags.debug);
-        const logger = getLogger();
         const projectRootDir = path.resolve(flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR || process.cwd());
-        const configManager = getConfigManager();
-        const loadConfigOutput = await configManager.loadConfig({ projectRootDir });
-        if (!loadConfigOutput.found) {
-            this.warn(`Project not initialized. Run 'hereya init' first.`);
-            return;
+        const myLogger = new ListrLogger({ useIcons: false });
+        const task = new Listr([
+            {
+                async task(ctx) {
+                    const configManager = getConfigManager();
+                    const loadConfigOutput = await configManager.loadConfig({ projectRootDir });
+                    if (!loadConfigOutput.found) {
+                        throw new Error("Project not initialized. Run 'hereya init' first.");
+                    }
+                    ctx.configOutput = loadConfigOutput;
+                    ctx.deployPackages = Object.keys(loadConfigOutput.config.deploy ?? {});
+                    ctx.packages = Object.keys(loadConfigOutput.config.packages ?? {});
+                    await delay(500);
+                },
+                title: 'Loading project config',
+            },
+            {
+                async task(ctx) {
+                    const backend = await getBackend();
+                    const { workspace } = flags;
+                    const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
+                        project: ctx.configOutput.config.project,
+                        workspace,
+                    });
+                    if (!getWorkspaceEnvOutput.success) {
+                        throw new Error(getWorkspaceEnvOutput.reason);
+                    }
+                    ctx.workspaceEnv = getWorkspaceEnvOutput.env;
+                    ctx.workspace = workspace;
+                    await delay(500);
+                },
+                title: 'Loading workspace environment variables',
+            },
+            {
+                async task(ctx) {
+                    const envManager = getEnvManager();
+                    const { env: projectEnv } = await envManager.getProjectEnv({
+                        markSecret: true,
+                        projectRootDir,
+                        workspace: ctx.workspace,
+                    });
+                    ctx.projectEnv = projectEnv;
+                    await delay(500);
+                },
+                title: 'Loading project environment variables',
+            },
+            {
+                async task(ctx) {
+                    const backend = await getBackend();
+                    const savedStateOutput = await backend.getState({
+                        project: ctx.configOutput.config.project,
+                    });
+                    if (savedStateOutput.found) {
+                        ctx.savedStateOutput = savedStateOutput;
+                    }
+                    await delay(500);
+                },
+                title: 'Loading project current state',
+            },
+            {
+                async task(ctx) {
+                    const savedDeployPackages = Object.keys(ctx.savedStateOutput?.config.deploy ?? {});
+                    ctx.removedDeployPackages = savedDeployPackages.filter((packageName) => !ctx.deployPackages.includes(packageName));
+                    const savedPackages = Object.keys(ctx.savedStateOutput?.config.packages ?? {});
+                    ctx.removedPackages = savedPackages.filter((packageName) => !ctx.packages.includes(packageName));
+                    await delay(500);
+                },
+                title: 'Identifying removed packages',
+            },
+            {
+                skip: (ctx) => ctx.removedDeployPackages.length === 0,
+                task(ctx, task) {
+                    return task.newListr(ctx.removedDeployPackages.map((packageName) => ({
+                        async task() {
+                            const parameterManager = getParameterManager();
+                            const { parameters } = await parameterManager.getPackageParameters({
+                                package: packageName,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            const destroyOutput = await destroyPackage({
+                                env: ctx.workspaceEnv,
+                                isDeploying: true,
+                                package: packageName,
+                                parameters,
+                                project: ctx.configOutput.config.project,
+                                projectEnv: ctx.projectEnv,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            if (!destroyOutput.success) {
+                                throw new Error(destroyOutput.reason);
+                            }
+                        },
+                        title: `Destroying package ${packageName}`,
+                    })), { concurrent: true });
+                },
+                title: 'Destroying removed deployment packages',
+            },
+            {
+                skip: (ctx) => ctx.removedPackages.length === 0,
+                task(ctx, task) {
+                    return task.newListr(ctx.removedPackages.map((packageName) => ({
+                        async task() {
+                            const parameterManager = getParameterManager();
+                            const { parameters } = await parameterManager.getPackageParameters({
+                                package: packageName,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            const destroyOutput = await destroyPackage({
+                                env: ctx.workspaceEnv,
+                                isDeploying: true,
+                                package: packageName,
+                                parameters,
+                                project: ctx.configOutput.config.project,
+                                workspace: ctx.workspace,
+                            });
+                            if (!destroyOutput.success) {
+                                throw new Error(destroyOutput.reason);
+                            }
+                            const { env, metadata } = destroyOutput;
+                            const output = ctx.removed || [];
+                            output.push({ env, metadata, packageName });
+                            ctx.removed = output;
+                        },
+                        title: `Destroying ${packageName}`,
+                    })), { concurrent: true });
+                },
+                title: 'Destroying removed packages',
+            },
+            {
+                skip: (ctx) => !ctx.packages || ctx.packages.length === 0,
+                async task(ctx, task) {
+                    if (!ctx.packages || ctx.packages.length === 0) {
+                        return;
+                    }
+                    return task.newListr(ctx.packages.map((packageName) => ({
+                        async task() {
+                            const parameterManager = getParameterManager();
+                            const { parameters } = await parameterManager.getPackageParameters({
+                                package: packageName,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            const provisionOutput = await provisionPackage({
+                                env: ctx.workspaceEnv,
+                                isDeploying: true,
+                                package: packageName,
+                                parameters,
+                                project: ctx.configOutput.config.project,
+                                workspace: ctx.workspace,
+                            });
+                            if (!provisionOutput.success) {
+                                throw new Error(provisionOutput.reason);
+                            }
+                            const { env, metadata } = provisionOutput;
+                            const output = ctx.added || [];
+                            output.push({ env, metadata, packageName });
+                            ctx.added = output;
+                        },
+                        title: `Provisioning ${packageName}`,
+                    })), { concurrent: true });
+                },
+                title: `Provisioning packages`,
+            },
+            {
+                skip: (ctx) => !ctx.removed || ctx.removed.length === 0,
+                async task(ctx) {
+                    if (!ctx.removed || ctx.removed.length === 0) {
+                        return;
+                    }
+                    const envManager = getEnvManager();
+                    for (const { env, metadata } of ctx.removed) {
+                        // eslint-disable-next-line no-await-in-loop
+                        await Promise.all([
+                            envManager.removeProjectEnv({
+                                env,
+                                infra: metadata.originalInfra ?? metadata.infra,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            }),
+                        ]);
+                    }
+                    await delay(500);
+                },
+                title: 'Removing env vars from removed packages',
+            },
+            {
+                skip: (ctx) => !ctx.added || ctx.added.length === 0,
+                async task(ctx) {
+                    if (!ctx.added || ctx.added.length === 0) {
+                        return;
+                    }
+                    const envManager = getEnvManager();
+                    for (const { env, metadata } of ctx.added) {
+                        // eslint-disable-next-line no-await-in-loop
+                        await envManager.addProjectEnv({
+                            env,
+                            infra: metadata.originalInfra ?? metadata.infra,
+                            projectRootDir,
+                            workspace: ctx.workspace,
+                        });
+                    }
+                    await delay(500);
+                },
+                title: 'Adding env vars from added packages',
+            },
+            {
+                async task() {
+                    const backend = await getBackend();
+                    const configManager = getConfigManager();
+                    const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+                    await backend.saveState(newConfig);
+                    await delay(500);
+                },
+                title: 'Saving state',
+            },
+            {
+                skip: (ctx) => ctx.deployPackages.length === 0,
+                task(ctx, task) {
+                    return task.newListr(ctx.deployPackages.map((packageName) => ({
+                        async task() {
+                            const parameterManager = getParameterManager();
+                            const { parameters } = await parameterManager.getPackageParameters({
+                                package: packageName,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            const provisionOutput = await provisionPackage({
+                                env: ctx.workspaceEnv,
+                                isDeploying: true,
+                                package: packageName,
+                                parameters,
+                                project: ctx.configOutput.config.project,
+                                projectEnv: ctx.projectEnv,
+                                projectRootDir,
+                                workspace: ctx.workspace,
+                            });
+                            if (!provisionOutput.success) {
+                                throw new Error(provisionOutput.reason);
+                            }
+                        },
+                        title: `Provisioning package ${packageName}`,
+                    })), { concurrent: true });
+                },
+                title: 'Provisioning deployment packages',
+            },
+        ]);
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, 'Deployment completed successfully');
         }
-        const { config } = loadConfigOutput;
-        const deployPackages = Object.keys(config.deploy ?? {});
-        const backend = await getBackend();
-        const savedStateOutput = await backend.getState({
-            project: config.project,
-        });
-        let savedPackages = [];
-        if (savedStateOutput.found) {
-            savedPackages = Object.keys(savedStateOutput.config.deploy ?? {});
+        catch (error) {
+            myLogger.log(ListrLogLevels.FAILED, error);
+            this.error(error.message);
         }
-        const removedPackages = savedPackages.filter((packageName) => !deployPackages.includes(packageName));
-        const { workspace } = flags;
-        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
-            project: config.project,
-            workspace,
-        });
-        if (!getWorkspaceEnvOutput.success) {
-            this.error(getWorkspaceEnvOutput.reason);
-        }
-        const { env: workspaceEnv } = getWorkspaceEnvOutput;
-        const parameterManager = getParameterManager();
-        const envManager = getEnvManager();
-        const { env: projectEnv } = await envManager.getProjectEnv({
-            markSecret: true,
-            projectRootDir,
-            workspace,
-        });
-        if (removedPackages.length > 0) {
-            logger.log(`Destroying ${removedPackages.length} removed packages`);
-        }
-        await Promise.all(removedPackages.map(async (packageName) => {
-            const { parameters } = await parameterManager.getPackageParameters({
-                package: packageName,
-                projectRootDir,
-                workspace,
-            });
-            const destroyOutput = await destroyPackage({
-                env: workspaceEnv,
-                isDeploying: true,
-                package: packageName,
-                parameters,
-                project: config.project,
-                projectEnv,
-                projectRootDir,
-                workspace,
-            });
-            if (!destroyOutput.success) {
-                this.error(destroyOutput.reason);
-            }
-        }));
-        if (removedPackages.length > 0) {
-            logger.done(`Destroyed ${removedPackages.length} removed packages`);
-        }
-        await Up.run(['--chdir', projectRootDir, '--workspace', workspace, '--deploy']);
-        logger.log(`Provisioning ${deployPackages.length} deployment packages`);
-        const { env: newProjectEnv } = await envManager.getProjectEnv({
-            markSecret: true,
-            projectRootDir,
-            workspace,
-        });
-        await Promise.all(deployPackages.map(async (packageName) => {
-            const { parameters } = await parameterManager.getPackageParameters({
-                package: packageName,
-                projectRootDir,
-                workspace,
-            });
-            const provisionOutput = await provisionPackage({
-                env: workspaceEnv,
-                isDeploying: true,
-                package: packageName,
-                parameters,
-                project: config.project,
-                projectEnv: newProjectEnv,
-                projectRootDir,
-                workspace,
-            });
-            if (!provisionOutput.success) {
-                this.error(provisionOutput.reason);
-            }
-            this.log(`Package ${packageName} deployed successfully`);
-            logEnv(provisionOutput.env, this.log.bind(this));
-        }));
-        logger.done(`Provisioned ${deployPackages.length} deployment packages`);
     }
 }

package/dist/commands/down/index.js

@@ -1,16 +1,14 @@
 import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogLevels, ListrLogger } from 'listr2';
 import { getBackend } from '../../backend/index.js';
 import { destroyPackage } from '../../infrastructure/index.js';
 import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
-import { getLogger } from '../../lib/log.js';
 import { getParameterManager } from '../../lib/parameter/index.js';
-import { setDebug } from '../../lib/shell.js';
+import { delay, setDebug } from '../../lib/shell.js';
 export default class Down extends Command {
     static description = 'Destroy all packages in the project.';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         chdir: Flags.string({
             description: 'directory to run command in',
@@ -33,61 +31,137 @@ export default class Down extends Command {
     async run() {
         const { flags } = await this.parse(Down);
         setDebug(flags.debug);
-        const logger = getLogger();
         const projectRootDir = flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR;
-        const configManager = getConfigManager();
-        const loadConfigOutput = await configManager.loadConfig({ projectRootDir });
-        if (!loadConfigOutput.found) {
-            this.warn(`Project not initialized. Run 'hereya init' first.`);
-            return;
+        const myLogger = new ListrLogger({ useIcons: false });
+        const task = new Listr([
+            {
+                async task(ctx, task) {
+                    return task.newListr([
+                        {
+                            async task(ctx) {
+                                const configManager = getConfigManager();
+                                const loadConfigOutput = await configManager.loadConfig({ projectRootDir });
+                                if (!loadConfigOutput.found) {
+                                    throw new Error("Project not initialized. Run 'hereya init' first.");
+                                }
+                                ctx.configOutput = loadConfigOutput;
+                                await delay(500);
+                            },
+                            title: 'Loading project config',
+                        },
+                        {
+                            async task(ctx) {
+                                const backend = await getBackend();
+                                const workspace = flags.workspace || ctx.configOutput.config.workspace;
+                                const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
+                                    project: ctx.configOutput.config.project,
+                                    workspace,
+                                });
+                                if (!getWorkspaceEnvOutput.success) {
+                                    throw new Error(getWorkspaceEnvOutput.reason);
+                                }
+                                ctx.workspaceEnvOutput = getWorkspaceEnvOutput;
+                                ctx.workspace = workspace;
+                                await delay(500);
+                            },
+                            title: 'Loading workspace environment variables',
+                        },
+                        {
+                            async task(ctx) {
+                                const packages = Object.keys(ctx.configOutput.config.packages ?? {});
+                                const backend = await getBackend();
+                                const savedStateOutput = await backend.getState({
+                                    project: ctx.configOutput.config.project,
+                                });
+                                let removedPackages = [];
+                                if (savedStateOutput.found) {
+                                    const savedPackages = Object.keys(savedStateOutput.config.packages ?? {});
+                                    removedPackages = savedPackages.filter((packageName) => !packages.includes(packageName));
+                                }
+                                ctx.packages = [...packages, ...removedPackages];
+                                await delay(500);
+                            },
+                            title: 'Identifying packages to destroy',
+                        },
+                        {
+                            skip: (ctx) => !ctx.packages || ctx.packages.length === 0,
+                            async task(ctx) {
+                                const { configOutput, destroyed, packages, workspace, workspaceEnvOutput } = ctx;
+                                if (!packages || packages.length === 0) {
+                                    return;
+                                }
+                                return task.newListr(packages.map((packageName) => ({
+                                    async task() {
+                                        const parameterManager = getParameterManager();
+                                        const { parameters } = await parameterManager.getPackageParameters({
+                                            package: packageName,
+                                            projectRootDir,
+                                            workspace,
+                                        });
+                                        const destroyOutput = await destroyPackage({
+                                            env: workspaceEnvOutput.env,
+                                            isDeploying: flags.deploy,
+                                            package: packageName,
+                                            parameters,
+                                            project: configOutput.config.project,
+                                            workspace,
+                                        });
+                                        if (!destroyOutput.success) {
+                                            throw new Error(destroyOutput.reason);
+                                        }
+                                        const { env, metadata } = destroyOutput;
+                                        const output = destroyed || [];
+                                        output.push({ env, metadata, packageName });
+                                        ctx.destroyed = output;
+                                    },
+                                    title: `Destroying ${packageName}`,
+                                })), { concurrent: true });
+                            },
+                            title: `Destroying packages`,
+                        },
+                        {
+                            skip: (ctx) => !ctx.destroyed || ctx.destroyed.length === 0,
+                            async task(ctx) {
+                                const { destroyed, workspace } = ctx;
+                                if (!destroyed || destroyed.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata } of destroyed) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await envManager.removeProjectEnv({
+                                        env,
+                                        infra: metadata.originalInfra ?? metadata.infra,
+                                        projectRootDir,
+                                        workspace,
+                                    });
+                                }
+                                await delay(500);
+                            },
+                            title: 'Removing env vars from destroyed packages',
+                        },
+                        {
+                            async task() {
+                                const backend = await getBackend();
+                                const configManager = getConfigManager();
+                                const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+                                await backend.saveState(newConfig);
+                                await delay(500);
+                            },
+                            title: 'Saving state',
+                        },
+                    ], { concurrent: false });
+                },
+                title: 'Shutting down the project',
+            },
+        ]);
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, 'Project shut down successfully');
         }
-        const { config } = loadConfigOutput;
-        const packages = Object.keys(config.packages ?? {});
-        const workspace = flags.workspace || config.workspace;
-        const backend = await getBackend();
-        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
-            project: config.project,
-            workspace,
-        });
-        if (!getWorkspaceEnvOutput.success) {
-            this.error(getWorkspaceEnvOutput.reason);
+        catch (error) {
+            myLogger.log(ListrLogLevels.FAILED, error);
+            this.error(error.message);
         }
-        const { env: workspaceEnv } = getWorkspaceEnvOutput;
-        const parameterManager = getParameterManager();
-        logger.log(`Destroying ${packages.length} packages`);
-        const result = await Promise.all(packages.map(async (packageName) => {
-            const { parameters } = await parameterManager.getPackageParameters({
-                package: packageName,
-                projectRootDir,
-                workspace,
-            });
-            const destroyOutput = await destroyPackage({
-                env: workspaceEnv,
-                isDeploying: flags.deploy,
-                package: packageName,
-                parameters,
-                project: config.project,
-                workspace,
-            });
-            if (!destroyOutput.success) {
-                this.error(destroyOutput.reason);
-            }
-            const { env, metadata } = destroyOutput;
-            return { env, metadata, packageName };
-        }));
-        logger.done(`Destroyed ${packages.length} packages`);
-        const envManager = getEnvManager();
-        for (const { env, metadata } of result) {
-            // eslint-disable-next-line no-await-in-loop
-            await envManager.removeProjectEnv({
-                env,
-                infra: metadata.originalInfra ?? metadata.infra,
-                projectRootDir,
-                workspace,
-            });
-        }
-        logger.done(`Removed environment variables of ${packages.length} packages`);
-        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
-        await backend.saveState(newConfig);
     }
 }