hereya-cli 0.2.1

package/dist/commands/remove/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class Remove extends Command {
+    static args: {
+        package: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        chdir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/remove/index.js

@@ -0,0 +1,80 @@
+import { Args, Command, Flags } from '@oclif/core';
+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 { getParameterManager } from '../../lib/parameter/index.js';
+export default class Remove extends Command {
+    static args = {
+        package: Args.string({
+            description: 'The package to remove. Packages are gitHub repositories. Use the format owner/repository',
+            required: true
+        }),
+    };
+    static description = 'Remove a package from the project.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> cloudy/docker_postgres',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'directory to run command in',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        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 { config } = loadConfigOutput;
+        if (!(args.package in (config.packages ?? {}))) {
+            this.warn(`Package ${args.package} not found in project.`);
+            return;
+        }
+        const backend = await getBackend();
+        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
+            project: config.project,
+            workspace: config.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            this.error(getWorkspaceEnvOutput.reason);
+        }
+        const { env: workspaceEnv } = getWorkspaceEnvOutput;
+        const parameterManager = getParameterManager();
+        const { parameters } = await parameterManager.getPackageParameters({
+            package: args.package,
+            projectRootDir,
+            workspace: config.workspace,
+        });
+        const destroyOutput = await destroyPackage({
+            env: workspaceEnv,
+            package: args.package,
+            parameters,
+            project: config.project,
+            workspace: config.workspace,
+        });
+        if (!destroyOutput.success) {
+            this.error(destroyOutput.reason);
+        }
+        const { env, metadata } = destroyOutput;
+        this.log(`Infrastructure resources for ${args.package} have been destroyed`);
+        this.log('removing package env vars from project');
+        const envManager = getEnvManager();
+        await envManager.removeProjectEnv({
+            env,
+            infra: metadata.infra,
+            projectRootDir,
+            workspace: config.workspace
+        });
+        await configManager.removePackage({
+            package: args.package,
+            projectRootDir
+        });
+        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+        await backend.saveState(newConfig);
+    }
+}

package/dist/commands/run/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Run extends Command {
+    static args: {
+        cmd: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        chdir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/run/index.js

@@ -0,0 +1,60 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getConfigManager } from '../../lib/config/index.js';
+import { getEnvManager } from '../../lib/env/index.js';
+import { runShell } from '../../lib/shell.js';
+export default class Run extends Command {
+    static args = {
+        cmd: Args.string({ description: 'command to run', required: true }),
+    };
+    static description = 'Run a command with hereya env vars.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -- npm run dev',
+        '<%= config.bin %> <%= command.id %> -w uat -- node index.js',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'directory to run command in',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to run the command in',
+            required: false,
+        }),
+    };
+    static strict = false;
+    async run() {
+        const { args, argv, flags } = await this.parse(Run);
+        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 { config } = loadConfigOutput;
+        let { workspace } = flags;
+        if (!workspace) {
+            workspace = config.workspace;
+        }
+        if (!workspace) {
+            this.error('you must specify a workspace to run the command in');
+        }
+        const envManager = getEnvManager();
+        const { env } = await envManager.getProjectEnv({
+            projectRootDir,
+            workspace,
+        });
+        const { cmd } = args;
+        const cmdArgs = argv.slice(1);
+        this.log(`Running command "${cmd} ${cmdArgs.join(' ')}" ...`);
+        const res = runShell(cmd, cmdArgs, {
+            directory: projectRootDir,
+            env: { ...process.env, ...env },
+            stdio: 'inherit',
+        });
+        if (res.status !== 0) {
+            this.error(res.error?.message || 'Command failed');
+        }
+    }
+}

package/dist/commands/up/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Up extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        chdir: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/up/index.js

@@ -0,0 +1,121 @@
+import { Command, Flags } from '@oclif/core';
+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 { getParameterManager } from '../../lib/parameter/index.js';
+export default class Up extends Command {
+    static description = 'Provision all packages in the project.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'directory to run command in',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to install the packages for',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Up);
+        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 { 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 ?? {});
+        }
+        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();
+        const removed = await Promise.all(removedPackages.map(async (packageName) => {
+            const { parameters } = await parameterManager.getPackageParameters({
+                package: packageName,
+                projectRootDir,
+                workspace,
+            });
+            const destroyOutput = await destroyPackage({
+                env: workspaceEnv,
+                package: packageName,
+                parameters,
+                project: config.project,
+                workspace,
+            });
+            if (!destroyOutput.success) {
+                this.error(destroyOutput.reason);
+            }
+            this.log(`Package ${packageName} destroyed successfully`);
+            const { env, metadata } = destroyOutput;
+            return { env, metadata, packageName };
+        }));
+        const added = await Promise.all(packages.map(async (packageName) => {
+            const { parameters } = await parameterManager.getPackageParameters({
+                package: packageName,
+                projectRootDir,
+                workspace,
+            });
+            const provisionOutput = await provisionPackage({
+                env: workspaceEnv,
+                package: packageName,
+                parameters,
+                project: config.project,
+                workspace,
+            });
+            if (!provisionOutput.success) {
+                this.error(provisionOutput.reason);
+            }
+            const { env, metadata } = provisionOutput;
+            this.log(`Package ${packageName} provisioned successfully`);
+            return { env, metadata, packageName };
+        }));
+        const envManager = getEnvManager();
+        for (const { env, metadata, packageName } of removed) {
+            // eslint-disable-next-line no-await-in-loop
+            await Promise.all([
+                envManager.removeProjectEnv({
+                    env,
+                    infra: metadata.infra,
+                    projectRootDir,
+                    workspace,
+                }),
+                configManager.removePackage({
+                    package: packageName,
+                    projectRootDir,
+                })
+            ]);
+        }
+        for (const { env, metadata } of added) {
+            // eslint-disable-next-line no-await-in-loop
+            await envManager.addProjectEnv({
+                env,
+                infra: metadata.infra,
+                projectRootDir,
+                workspace,
+            });
+        }
+        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+        await backend.saveState(newConfig);
+    }
+}

package/dist/commands/workspace/create/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceCreate extends Command {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/workspace/create/index.js

@@ -0,0 +1,25 @@
+import { Args, Command } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
+export default class WorkspaceCreate extends Command {
+    static args = {
+        name: Args.string({ description: 'name of the workspace to create', required: true }),
+    };
+    static description = 'Create a new workspace if it does not exist.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> dev',
+    ];
+    async run() {
+        const { args } = await this.parse(WorkspaceCreate);
+        const backend = await getBackend();
+        const createWorkspaceOutput = await backend.createWorkspace({ name: args.name });
+        if (!createWorkspaceOutput.success) {
+            this.error(`Failed to create workspace: ${createWorkspaceOutput.reason}`);
+        }
+        if (createWorkspaceOutput.isNew) {
+            this.log(`Workspace ${createWorkspaceOutput.workspace.name} created successfully!`);
+        }
+        else {
+            this.warn(`Workspace ${createWorkspaceOutput.workspace.name} already exists.`);
+        }
+    }
+}

package/dist/commands/workspace/delete/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceDelete extends Command {
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/workspace/delete/index.js

@@ -0,0 +1,24 @@
+import { Args, Command } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
+export default class WorkspaceDelete extends Command {
+    static args = {
+        name: Args.string({ description: 'name of the workspace to delete', required: true }),
+    };
+    static description = 'Delete a workspace if it exists.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> dev',
+    ];
+    async run() {
+        const { args } = await this.parse(WorkspaceDelete);
+        const backend = await getBackend();
+        const output = await backend.deleteWorkspace({ name: args.name });
+        if (!output.success) {
+            this.error(`Failed to delete workspace: ${output.reason}`);
+        }
+        if (output.message) {
+            this.log(output.message);
+            return;
+        }
+        this.log(`Workspace ${args.name} deleted successfully!`);
+    }
+}

package/dist/commands/workspace/env/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceEnv extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspace/env/index.js

@@ -0,0 +1,28 @@
+import { Command, Flags } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
+import { logEnv } from '../../../lib/env-utils.js';
+export default class WorkspaceEnv extends Command {
+    static description = 'Print workspace env vars.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -w dev',
+    ];
+    static flags = {
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to print env vars for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspaceEnv);
+        const backend = await getBackend();
+        const getWorkspaceEnvOutput = await backend.getWorkspaceEnv({
+            workspace: flags.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            this.error(getWorkspaceEnvOutput.reason);
+        }
+        const { env } = getWorkspaceEnvOutput;
+        logEnv(env);
+    }
+}

package/dist/commands/workspace/install/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceInstall extends Command {
+    static args: {
+        package: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        parameter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'parameter-file': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspace/install/index.js

@@ -0,0 +1,74 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
+import { provisionPackage } from '../../../infrastructure/index.js';
+import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { load } from '../../../lib/yaml-utils.js';
+export default class WorkspaceInstall extends Command {
+    static args = {
+        package: Args.string({
+            description: 'The package to add. Packages are gitHub repositories. Use the format owner/repository',
+            required: true
+        }),
+    };
+    static description = 'Add a package to the workspace.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> hereya/aws-cognito',
+    ];
+    static flags = {
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: 'parameter for the package, in the form of \'key=value\'. Can be specified multiple times.',
+            multiple: true,
+        }),
+        'parameter-file': Flags.string({
+            char: 'f',
+            description: 'path to a file containing parameters for the package',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to add the package to',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkspaceInstall);
+        const backend = await getBackend();
+        const loadWorkspaceOutput = await backend.getWorkspace(flags.workspace);
+        if (!loadWorkspaceOutput.found || loadWorkspaceOutput.hasError) {
+            this.error(`Workspace ${flags.workspace} not found`);
+        }
+        const parametersInCmdline = arrayOfStringToObject(flags.parameter);
+        let parametersFromFile = {};
+        if (flags['parameter-file']) {
+            const { data, found } = await load(flags['parameter-file']);
+            if (!found) {
+                this.error(`Parameter file ${flags['parameter-file']} not found`);
+            }
+            parametersFromFile = data;
+        }
+        const parameters = { ...parametersFromFile, ...parametersInCmdline };
+        const provisionOutput = await provisionPackage({
+            package: args.package,
+            parameters,
+            workspace: flags.workspace,
+        });
+        if (!provisionOutput.success) {
+            this.error(provisionOutput.reason);
+        }
+        const { env, metadata } = provisionOutput;
+        this.log(`Package ${args.package} provisioned successfully`);
+        this.log(`Saving exported environment variables to workspace ${flags.workspace}...`);
+        const output = await backend.addPackageToWorkspace({
+            env,
+            infra: metadata.infra,
+            package: args.package,
+            parameters,
+            workspace: flags.workspace,
+        });
+        if (!output.success) {
+            this.error(output.reason);
+        }
+        this.log(`Package ${args.package} added to workspace ${flags.workspace}`);
+    }
+}

package/dist/commands/workspace/uninstall/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceUninstall extends Command {
+    static args: {
+        package: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        parameter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'parameter-file': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        workspace: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspace/uninstall/index.js

@@ -0,0 +1,85 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
+import { destroyPackage } from '../../../infrastructure/index.js';
+import { arrayOfStringToObject } from '../../../lib/object-utils.js';
+import { load } from '../../../lib/yaml-utils.js';
+export default class WorkspaceUninstall extends Command {
+    static args = {
+        package: Args.string({
+            description: 'The package to remove. Packages are gitHub repositories. Use the format owner/repository',
+            required: true
+        }),
+    };
+    static description = 'Remove a package from a workspace.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> hereya/aws-cognito',
+    ];
+    static flags = {
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: 'parameter for the package, in the form of \'key=value\'. Can be specified multiple times.',
+            multiple: true,
+        }),
+        'parameter-file': Flags.string({
+            char: 'f',
+            description: 'path to a file containing parameters for the package',
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to remove the package from',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkspaceUninstall);
+        const backend = await getBackend();
+        const loadWorkspaceOutput = await backend.getWorkspace(flags.workspace);
+        if (!loadWorkspaceOutput.found) {
+            this.error(`Workspace ${flags.workspace} not found`);
+        }
+        if (loadWorkspaceOutput.hasError) {
+            this.error(`Error loading workspace ${flags.workspace}: ${loadWorkspaceOutput.error}`);
+        }
+        const { workspace } = loadWorkspaceOutput;
+        if (!(args.package in (workspace.packages ?? {}))) {
+            this.log(`Package ${args.package} not found in workspace ${flags.workspace}`);
+            return;
+        }
+        const parametersInCmdline = arrayOfStringToObject(flags.parameter);
+        let parametersFromFile = {};
+        if (flags['parameter-file']) {
+            const { data, found } = await load(flags['parameter-file']);
+            if (!found) {
+                this.error(`Parameter file ${flags['parameter-file']} not found`);
+            }
+            parametersFromFile = data;
+        }
+        const parameters = {
+            ...workspace.packages?.[args.package].parameters,
+            ...parametersFromFile,
+            ...parametersInCmdline
+        };
+        const destroyOutput = await destroyPackage({
+            package: args.package,
+            parameters,
+            workspace: flags.workspace,
+        });
+        if (!destroyOutput.success) {
+            this.error(destroyOutput.reason);
+        }
+        const { env, metadata } = destroyOutput;
+        this.log(`Package ${args.package} removed successfully`);
+        this.log(`removing exported environment variables from workspace ${flags.workspace}...`);
+        const output = await backend.removePackageFromWorkspace({
+            env,
+            infra: metadata.infra,
+            package: args.package,
+            workspace: flags.workspace,
+        });
+        if (!output.success) {
+            this.error(output.reason);
+        }
+        this.log(`Package ${args.package} removed from workspace ${flags.workspace}`);
+    }
+}

package/dist/iac/cdk.d.ts

@@ -0,0 +1,8 @@
+import { ApplyInput, ApplyOutput, DestroyInput, DestroyOutput, Iac } from './common.js';
+export declare class Cdk implements Iac {
+    apply(input: ApplyInput): Promise<ApplyOutput>;
+    destroy(input: DestroyInput): Promise<DestroyOutput>;
+    private getEnv;
+    private getParameterNames;
+    private getStack;
+}