hereya-cli 0.12.0 → 0.13.1

package/dist/commands/up/index.js

@@ -3,17 +3,21 @@ 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';
 export default class Up extends Command {
     static description = 'Provision 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',
             required: false,
         }),
+        debug: Flags.boolean({
+            default: false,
+            description: 'enable debug mode',
+        }),
         deploy: Flags.boolean({
             description: 'provision deployment companion packages',
             required: false,
@@ -26,6 +30,8 @@ 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 });
@@ -54,6 +60,9 @@ export default class Up extends Command {
         }
         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,
@@ -71,10 +80,13 @@ export default class Up extends Command {
             if (!destroyOutput.success) {
                 this.error(destroyOutput.reason);
             }
-            this.log(`Package ${packageName} destroyed successfully`);
             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,
@@ -93,9 +105,9 @@ export default class Up extends Command {
                 this.error(provisionOutput.reason);
             }
             const { env, metadata } = provisionOutput;
-            this.log(`Package ${packageName} provisioned successfully`);
             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
@@ -108,6 +120,9 @@ export default class Up extends Command {
                 }),
             ]);
         }
+        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({
@@ -117,6 +132,7 @@ export default class Up extends Command {
                 workspace,
             });
         }
+        logger.done('Saved exported environment variables');
         const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
         await backend.saveState(newConfig);
     }

package/dist/infrastructure/index.js

@@ -10,19 +10,19 @@ export function getInfrastructure(input) {
         case InfrastructureType.local: {
             return {
                 infrastructure: localInfrastructure,
-                supported: true
+                supported: true,
             };
         }
         case InfrastructureType.aws: {
             return {
                 infrastructure: awsInfrastructure,
-                supported: true
+                supported: true,
             };
         }
         default: {
             return {
                 reason: `Infrastructure type ${input.type} is not supported yet!`,
-                supported: false
+                supported: false,
             };
         }
     }
@@ -38,7 +38,6 @@ export async function destroyPackage(input) {
         return { reason: infrastructure$.reason, success: false };
     }
     if (metadata.deploy && input.skipDeploy) {
-        console.log(`Skipping un-deployment of ${input.package}...`);
         return { env: {}, metadata, success: true };
     }
     const { infrastructure } = infrastructure$;
@@ -46,31 +45,33 @@ export async function destroyPackage(input) {
     const id$ = await backend.getProvisioningId({
         packageCanonicalName: canonicalName,
         project: input.project,
-        workspace: input.workspace
+        workspace: input.workspace,
     });
     if (!id$.success) {
         return { reason: id$.reason, success: false };
     }
     const { id } = id$;
-    const destroyOutput = metadata.deploy ? await infrastructure.undeploy({
-        canonicalName,
-        env: input.env,
-        iacType: metadata.iac,
-        id,
-        parameters: input.parameters,
-        pkgName,
-        pkgUrl: packageUri,
-        projectEnv: input.projectEnv ?? {},
-        projectRootDir: input.projectRootDir,
-    }) : await infrastructure.destroy({
-        canonicalName,
-        env: input.env,
-        iacType: metadata.iac,
-        id,
-        parameters: input.parameters,
-        pkgName,
-        pkgUrl: packageUri,
-    });
+    const destroyOutput = metadata.deploy
+        ? await infrastructure.undeploy({
+            canonicalName,
+            env: input.env,
+            iacType: metadata.iac,
+            id,
+            parameters: input.parameters,
+            pkgName,
+            pkgUrl: packageUri,
+            projectEnv: input.projectEnv ?? {},
+            projectRootDir: input.projectRootDir,
+        })
+        : await infrastructure.destroy({
+            canonicalName,
+            env: input.env,
+            iacType: metadata.iac,
+            id,
+            parameters: input.parameters,
+            pkgName,
+            pkgUrl: packageUri,
+        });
     if (!destroyOutput.success) {
         return { reason: destroyOutput.reason, success: false };
     }
@@ -79,10 +80,12 @@ export async function destroyPackage(input) {
         ...input,
         package: depName,
     })));
-    if (!depsOutput.every(output => output.success)) {
+    if (!depsOutput.every((output) => output.success)) {
         return {
-            reason: `Failed to destroy all dependencies: ${depsOutput.filter(o => !o.success).map(o => !o.success && o.reason)}`,
-            success: false
+            reason: `Failed to destroy all dependencies: ${depsOutput
+                .filter((o) => !o.success)
+                .map((o) => !o.success && o.reason)}`,
+            success: false,
         };
     }
     return { env: destroyOutput.env, metadata, success: true };
@@ -98,7 +101,6 @@ export async function provisionPackage(input) {
         return { reason: infrastructure$.reason, success: false };
     }
     if (metadata.deploy && input.skipDeploy) {
-        console.log(`Skipping deployment of ${input.package}...`);
         return { env: {}, metadata, success: true };
     }
     const dependencies = metadata.dependencies ?? {};
@@ -106,10 +108,12 @@ export async function provisionPackage(input) {
         ...input,
         package: depName,
     })));
-    if (!depsOutput.every(output => output.success)) {
+    if (!depsOutput.every((output) => output.success)) {
         return {
-            reason: `Failed to provision all dependencies: ${depsOutput.filter(o => !o.success).map(o => !o.success && o.reason)}`,
-            success: false
+            reason: `Failed to provision all dependencies: ${depsOutput
+                .filter((o) => !o.success)
+                .map((o) => !o.success && o.reason)}`,
+            success: false,
         };
     }
     let depsEnv = {};
@@ -126,31 +130,33 @@ export async function provisionPackage(input) {
     const id$ = await backend.getProvisioningId({
         packageCanonicalName: canonicalName,
         project: input.project,
-        workspace: input.workspace
+        workspace: input.workspace,
     });
     if (!id$.success) {
         return { reason: id$.reason, success: false };
     }
     const { id } = id$;
-    const provisionOutput = metadata.deploy ? await infrastructure.deploy({
-        canonicalName,
-        env: { ...input.env, ...depsEnv },
-        iacType: metadata.iac,
-        id,
-        parameters: input.parameters,
-        pkgName,
-        pkgUrl: packageUri,
-        projectEnv: input.projectEnv ?? {},
-        projectRootDir: input.projectRootDir,
-    }) : await infrastructure.provision({
-        canonicalName,
-        env: input.env,
-        iacType: metadata.iac,
-        id,
-        parameters: input.parameters,
-        pkgName,
-        pkgUrl: packageUri,
-    });
+    const provisionOutput = metadata.deploy
+        ? await infrastructure.deploy({
+            canonicalName,
+            env: { ...input.env, ...depsEnv },
+            iacType: metadata.iac,
+            id,
+            parameters: input.parameters,
+            pkgName,
+            pkgUrl: packageUri,
+            projectEnv: input.projectEnv ?? {},
+            projectRootDir: input.projectRootDir,
+        })
+        : await infrastructure.provision({
+            canonicalName,
+            env: input.env,
+            iacType: metadata.iac,
+            id,
+            parameters: input.parameters,
+            pkgName,
+            pkgUrl: packageUri,
+        });
     if (!provisionOutput.success) {
         return { reason: provisionOutput.reason, success: false };
     }

package/dist/lib/log.d.ts

@@ -0,0 +1,4 @@
+export declare function getLogger(): {
+    done(message: string): void;
+    log(message: string): void;
+};

package/dist/lib/log.js

@@ -0,0 +1,29 @@
+import cliSpinners from 'cli-spinners';
+import ora from 'ora';
+let spinner = null;
+const logger = {
+    done(message) {
+        if (!spinner) {
+            spinner = ora({
+                spinner: cliSpinners.aesthetic,
+                text: message,
+            });
+        }
+        spinner.succeed(message);
+        spinner = null;
+    },
+    log(message) {
+        if (spinner) {
+            spinner.text = message;
+            return;
+        }
+        spinner = ora({
+            spinner: cliSpinners.aesthetic,
+            text: message,
+        });
+        spinner.start();
+    },
+};
+export function getLogger() {
+    return logger;
+}

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

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

package/dist/lib/package/github.js

@@ -1,31 +1,31 @@
-import { Octokit } from '@octokit/rest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { downloadPackage } from './index.js';
 export class GitHubPackageManager {
-    async getRepoContent({ owner, path, repo }) {
-        const octokit = new Octokit();
+    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 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,
                 };
             }
             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,
             };
         }
     }

package/dist/lib/package/index.js

@@ -55,11 +55,9 @@ export function getPackageCanonicalName(packageName) {
 }
 export async function downloadPackage(pkgUrl, destPath) {
     if (await isNotEmpty(destPath)) {
-        console.log(`Package already downloaded at ${destPath}`);
         return destPath;
     }
     await fs.mkdir(destPath, { recursive: true });
-    console.log(`Downloading package from ${pkgUrl}`);
     // Initialize simple-git
     const git = simpleGit();
     // Clone repository into temp directory

package/dist/lib/shell.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { StdioOptions, spawnSync } from 'node:child_process';
+export declare function setDebug(value: boolean): void;
+export declare function isDebug(): boolean;
 export type RunShellOptions = {
     directory?: string;
     env?: NodeJS.ProcessEnv;

package/dist/lib/shell.js

@@ -1,4 +1,11 @@
 import { spawnSync } from 'node:child_process';
+let debug = false;
+export function setDebug(value) {
+    debug = value;
+}
+export function isDebug() {
+    return debug;
+}
 export function runShell(cmd, args, options = {}) {
     // Run the command
     const result = spawnSync(cmd, args, {
@@ -6,7 +13,7 @@ export function runShell(cmd, args, options = {}) {
         encoding: 'utf8',
         env: { ...process.env, ...options.env },
         shell: true,
-        stdio: options.stdio ?? 'inherit',
+        stdio: options.stdio ?? (isDebug() ? 'inherit' : 'ignore'),
     });
     // Throw an error if the command failed
     if (result.status !== 0) {