hereya-cli 0.13.0 → 0.14.0

package/dist/commands/up/index.js

@@ -1,11 +1,11 @@
 import { Command, Flags } from '@oclif/core';
+import { Listr, ListrLogLevels, ListrLogger } from 'listr2';
 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 { 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 Up extends Command {
     static description = 'Provision all packages in the project.';
     static examples = ['<%= config.bin %> <%= command.id %>'];
@@ -31,109 +31,201 @@ export default class Up extends Command {
     async run() {
         const { flags } = await this.parse(Up);
         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 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 packages = Object.keys(ctx.configOutput.config.packages ?? {});
+                                const savedPackages = Object.keys(ctx.savedStateOutput?.config?.packages ?? {});
+                                const removedPackages = savedPackages.filter((packageName) => !packages.includes(packageName));
+                                ctx.removedPackages = removedPackages;
+                                ctx.packages = packages;
+                                await delay(500);
+                            },
+                            title: 'Searching for removed packages',
+                        },
+                        {
+                            skip: (ctx) => !ctx.removedPackages || ctx.removedPackages.length === 0,
+                            async task(ctx) {
+                                const { configOutput, removed, removedPackages, workspace, workspaceEnvOutput } = ctx;
+                                if (!removedPackages || removedPackages.length === 0) {
+                                    return;
+                                }
+                                return task.newListr(removedPackages.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 = 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) {
+                                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.workspaceEnvOutput.env,
+                                            isDeploying: flags.deploy,
+                                            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) {
+                                const { removed, workspace } = ctx;
+                                if (!removed || removed.length === 0) {
+                                    return;
+                                }
+                                const envManager = getEnvManager();
+                                for (const { env, metadata } of removed) {
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await Promise.all([
+                                        envManager.removeProjectEnv({
+                                            env,
+                                            infra: metadata.originalInfra ?? metadata.infra,
+                                            projectRootDir,
+                                            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',
+                        },
+                    ], { concurrent: false });
+                },
+                title: 'Waking up the project',
+            },
+        ]);
+        try {
+            await task.run();
+            myLogger.log(ListrLogLevels.COMPLETED, 'Project waked up successfully');
         }
-        const { config } = loadConfigOutput;
-        const packages = Object.keys(config.packages ?? {});
-        const backend = await getBackend();
-        const savedStateOutput = await backend.getState({
-            project: config.project,
-        });
-        let savedPackages = [];
-        if (savedStateOutput.found) {
-            savedPackages = Object.keys(savedStateOutput.config.packages ?? {});
+        catch (error) {
+            myLogger.log(ListrLogLevels.FAILED, error);
+            this.error(error.message);
         }
-        const removedPackages = savedPackages.filter((packageName) => !packages.includes(packageName));
-        const workspace = flags.workspace || config.workspace;
-        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
-            project: config.project,
-            workspace,
-        });
-        if (!getWorkspaceEnvOutput.success) {
-            this.error(getWorkspaceEnvOutput.reason);
-        }
-        const { env: workspaceEnv } = getWorkspaceEnvOutput;
-        const parameterManager = getParameterManager();
-        if (removedPackages.length > 0) {
-            logger.log(`Destroying ${removedPackages.length} removed packages`);
-        }
-        const removed = await Promise.all(removedPackages.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 };
-        }));
-        if (removedPackages.length > 0) {
-            logger.done(`Destroyed ${removedPackages.length} removed packages`);
-        }
-        logger.log(`Provisioning ${packages.length} packages`);
-        const added = await Promise.all(packages.map(async (packageName) => {
-            const { parameters } = await parameterManager.getPackageParameters({
-                package: packageName,
-                projectRootDir,
-                workspace,
-            });
-            const provisionOutput = await provisionPackage({
-                env: workspaceEnv,
-                isDeploying: flags.deploy,
-                package: packageName,
-                parameters,
-                project: config.project,
-                workspace,
-            });
-            if (!provisionOutput.success) {
-                this.error(provisionOutput.reason);
-            }
-            const { env, metadata } = provisionOutput;
-            return { env, metadata, packageName };
-        }));
-        logger.done(`Provisioned ${packages.length} packages`);
-        const envManager = getEnvManager();
-        for (const { env, metadata } of removed) {
-            // eslint-disable-next-line no-await-in-loop
-            await Promise.all([
-                envManager.removeProjectEnv({
-                    env,
-                    infra: metadata.originalInfra ?? metadata.infra,
-                    projectRootDir,
-                    workspace,
-                }),
-            ]);
-        }
-        if (removedPackages.length > 0) {
-            logger.done(`Removed env vars from ${removedPackages.length} removed packages`);
-        }
-        for (const { env, metadata } of added) {
-            // eslint-disable-next-line no-await-in-loop
-            await envManager.addProjectEnv({
-                env,
-                infra: metadata.originalInfra ?? metadata.infra,
-                projectRootDir,
-                workspace,
-            });
-        }
-        logger.done('Saved exported environment variables');
-        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
-        await backend.saveState(newConfig);
     }
 }

package/dist/infrastructure/index.d.ts

@@ -47,3 +47,4 @@ export type GetInfrastructureOutput = {
     infrastructure: Infrastructure;
     supported: true;
 };
+export type PackageMetadata = z.infer<typeof PackageMetadata>;

package/dist/lib/log.js

@@ -1,27 +1,11 @@
-import cliSpinners from 'cli-spinners';
-import ora from 'ora';
-let spinner = null;
+import { ListrLogLevels, ListrLogger } from 'listr2';
+const myLogger = new ListrLogger({ useIcons: false });
 const logger = {
     done(message) {
-        if (!spinner) {
-            spinner = ora({
-                spinner: cliSpinners.aesthetic,
-                text: message,
-            });
-        }
-        spinner.succeed(message);
-        spinner = null;
+        myLogger.log(ListrLogLevels.COMPLETED, message);
     },
     log(message) {
-        if (spinner) {
-            spinner.text = message;
-            return;
-        }
-        spinner = ora({
-            spinner: cliSpinners.aesthetic,
-            text: message,
-        });
-        spinner.start();
+        myLogger.log(ListrLogLevels.OUTPUT, message);
     },
 };
 export function getLogger() {

package/dist/lib/package/common.d.ts

@@ -1,4 +1,5 @@
 export interface PackageManager {
+    downloadPackage: (pkgUrl: string, destPath: string) => Promise<string>;
     getRepoContent: (input: GetRepoContentInput) => Promise<GetRepoContentOutput>;
 }
 export type GetRepoContentInput = {
@@ -9,6 +10,7 @@ export type GetRepoContentInput = {
 export type GetRepoContentOutput = {
     content: string;
     found: true;
+    pkgUrl: string;
 } | {
     found: false;
     reason: string;

package/dist/lib/package/github.d.ts

@@ -1,4 +1,5 @@
 import type { GetRepoContentInput, GetRepoContentOutput, PackageManager } from './common.js';
 export declare class GitHubPackageManager implements PackageManager {
-    getRepoContent({ owner, path, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
+    downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
+    getRepoContent({ owner, path: filePath, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
 }

package/dist/lib/package/github.js

@@ -1,32 +1,61 @@
-import { Octokit } from '@octokit/rest';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { simpleGit } from 'simple-git';
+import { BackOffPolicy, Retryable } from 'typescript-retry-decorator';
+import { isNotEmpty } from '../filesystem.js';
 export class GitHubPackageManager {
-    async getRepoContent({ owner, path, repo }) {
-        const octokit = new Octokit();
+    // eslint-disable-next-line new-cap
+    async downloadPackage(pkgUrl, destPath) {
+        if (await isNotEmpty(destPath)) {
+            return destPath;
+        }
+        await fs.mkdir(destPath, { recursive: true });
+        // Initialize simple-git
+        const git = simpleGit();
+        // Clone repository into temp directory
+        await git.clone(pkgUrl, destPath, ['--depth=1']);
+        return destPath;
+    }
+    async getRepoContent({ owner, path: filePath, repo }) {
+        const pkgUrl = `https://github.com/${owner}/${repo}`;
+        const tmpFolder = path.join(os.tmpdir(), 'hereya', 'github', owner, repo);
         try {
-            const response = await octokit.rest.repos.getContent({
-                headers: {
-                    'Accept': 'application/vnd.github.raw+json'
-                },
-                owner,
-                path,
-                repo
-            });
-            if (response.status !== 200) {
+            const destPath = await this.downloadPackage(pkgUrl, tmpFolder);
+            if (await fs.stat(path.join(destPath, filePath))) {
+                const content = await fs.readFile(path.join(destPath, filePath), 'utf8');
+                // remove the tmp folder
+                await fs.rm(destPath, { recursive: true });
                 return {
-                    found: false,
-                    reason: `Failed to fetch content: ${response.status}`
+                    content,
+                    found: true,
+                    pkgUrl,
                 };
             }
             return {
-                content: response.data,
-                found: true
+                found: false,
+                reason: `File ${filePath} not found in ${pkgUrl}`,
             };
         }
         catch (error) {
             return {
                 found: false,
-                reason: error.message
+                reason: error.message,
             };
         }
     }
 }
+__decorate([
+    Retryable({
+        backOff: 1000,
+        backOffPolicy: BackOffPolicy.ExponentialBackOffPolicy,
+        exponentialOption: { maxInterval: 4000, multiplier: 3 },
+        maxAttempts: 3,
+    })
+], GitHubPackageManager.prototype, "downloadPackage", null);

package/dist/lib/package/index.js

@@ -1,10 +1,7 @@
-import * as fs from 'node:fs/promises';
-import { simpleGit } from 'simple-git';
 import * as yaml from 'yaml';
 import { z } from 'zod';
 import { IacType } from '../../iac/common.js';
 import { InfrastructureType } from '../../infrastructure/common.js';
-import { isNotEmpty } from '../filesystem.js';
 import { GitHubPackageManager } from './github.js';
 export const packageManager = new GitHubPackageManager();
 export function getPackageManager() {
@@ -16,14 +13,13 @@ export async function resolvePackage(input) {
         return { found: false, reason: 'Invalid package format. Use owner/repository' };
     }
     const [owner, repo] = pkgParts;
-    const pkgUrl = `https://github.com/${input.package}`;
     const packageManager = getPackageManager();
     const metadataContentCandidates = (await Promise.all([
         packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', repo }),
         packageManager.getRepoContent({ owner, path: 'hereyarc.yml', repo }),
     ])).filter((content$) => content$.found);
     if (metadataContentCandidates.length === 0) {
-        return { found: false, reason: `No hereya metadata file found in ${pkgUrl}` };
+        return { found: false, reason: `No hereya metadata file found in ${input.package}` };
     }
     const metadataContent$ = metadataContentCandidates[0];
     try {
@@ -34,15 +30,11 @@ export async function resolvePackage(input) {
         if (input.isDeploying && metadata.onDeploy) {
             return resolvePackage({ package: metadata.onDeploy.pkg });
         }
-        // if (process.env.HEREYA_OVERRIDE_INFRA) {
-        //   metadata.originalInfra = metadata.infra
-        //   metadata.infra = process.env.HEREYA_OVERRIDE_INFRA as InfrastructureType
-        // }
         return {
             canonicalName: getPackageCanonicalName(input.package),
             found: true,
             metadata,
-            packageUri: pkgUrl,
+            packageUri: metadataContent$.pkgUrl,
             pkgName: input.package,
         };
     }
@@ -54,15 +46,8 @@ export function getPackageCanonicalName(packageName) {
     return packageName.replace('/', '-');
 }
 export async function downloadPackage(pkgUrl, destPath) {
-    if (await isNotEmpty(destPath)) {
-        return destPath;
-    }
-    await fs.mkdir(destPath, { recursive: true });
-    // Initialize simple-git
-    const git = simpleGit();
-    // Clone repository into temp directory
-    await git.clone(pkgUrl, destPath, ['--depth=1']);
-    return destPath;
+    const packageManager = getPackageManager();
+    return packageManager.downloadPackage(pkgUrl, destPath);
 }
 export const PackageMetadata = z.object({
     dependencies: z.record(z.string()).optional(),

package/dist/lib/shell.d.ts

@@ -9,3 +9,4 @@ export type RunShellOptions = {
     stdio?: StdioOptions;
 };
 export declare function runShell(cmd: string, args: string[], options?: RunShellOptions): ReturnType<typeof spawnSync>;
+export declare function delay(ms: number): Promise<unknown> | undefined;

package/dist/lib/shell.js

@@ -21,3 +21,11 @@ export function runShell(cmd, args, options = {}) {
     }
     return result;
 }
+export function delay(ms) {
+    if (process.env.NODE_ENV === 'test') {
+        return;
+    }
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}