hereya-cli 0.2.1

package/dist/backend/local.js

@@ -0,0 +1,231 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { resolveEnvValues } from '../lib/env-utils.js';
+import { getAnyPath } from '../lib/filesystem.js';
+import { load, save } from '../lib/yaml-utils.js';
+const WorkspaceSchema = z.object({
+    env: z.record(z.string()).optional(),
+    id: z.string().min(2),
+    name: z.string().min(2),
+    packages: z.record(z.object({
+        parameters: z.record(z.any()).optional(),
+        version: z.string(),
+    })).optional(),
+});
+export class LocalBackend {
+    async addPackageToWorkspace(input) {
+        const workspace$ = await this.getWorkspace(input.workspace);
+        if (!workspace$.found) {
+            return {
+                reason: `Workspace ${input.workspace} not found`,
+                success: false,
+            };
+        }
+        if (workspace$.hasError) {
+            return {
+                reason: workspace$.error,
+                success: false,
+            };
+        }
+        const { workspace } = workspace$;
+        workspace.packages = {
+            ...workspace.packages,
+            [input.package]: {
+                parameters: input.parameters,
+                version: '',
+            },
+        };
+        const newEnv = Object.fromEntries(Object.entries(input.env)
+            .map(([key, value]) => [key, `${input.infra}:${value}`]));
+        workspace.env = {
+            ...workspace.env,
+            ...newEnv,
+        };
+        try {
+            await this.saveWorkspace(workspace, input.workspace);
+            return {
+                success: true,
+                workspace,
+            };
+        }
+        catch (error) {
+            return {
+                reason: error.message,
+                success: false,
+            };
+        }
+    }
+    async createWorkspace(input) {
+        const workspace$ = await this.getWorkspace(input.name);
+        if (workspace$.found) {
+            return workspace$.hasError ? {
+                reason: workspace$.error,
+                success: false,
+            } : {
+                isNew: false,
+                success: true,
+                workspace: workspace$.workspace,
+            };
+        }
+        const workspace = {
+            id: input.name,
+            name: input.name,
+        };
+        try {
+            await this.saveWorkspace(workspace, input.name);
+            return {
+                isNew: true,
+                success: true,
+                workspace,
+            };
+        }
+        catch (error) {
+            return {
+                reason: error.message,
+                success: false,
+            };
+        }
+    }
+    async deleteWorkspace(input) {
+        const workspace$ = await this.getWorkspace(input.name);
+        if (!workspace$.found) {
+            return {
+                message: `Workspace ${input.name} does not exist`,
+                success: true,
+            };
+        }
+        if (workspace$.hasError) {
+            return {
+                reason: workspace$.error,
+                success: false,
+            };
+        }
+        const { workspace } = workspace$;
+        if (Object.keys(workspace.packages ?? {}).length > 0) {
+            return {
+                reason: `Cannot delete workspace ${input.name} because it has packages`,
+                success: false,
+            };
+        }
+        const workspacePath = await this.getWorkspacePath(input.name);
+        await fs.rm(workspacePath);
+        return {
+            success: true,
+        };
+    }
+    async getState(input) {
+        const projectStatePath = await this.getProjectStatePath(input.project);
+        const { data, found } = await load(projectStatePath);
+        if (found) {
+            return {
+                config: data,
+                found: true,
+            };
+        }
+        return {
+            found: false,
+        };
+    }
+    async getWorkspace(workspace) {
+        const workspacePath = await getAnyPath(path.join(os.homedir(), '.hereya', 'state', 'workspaces', `${workspace}.yaml`), path.join(os.homedir(), '.hereya', 'state', 'workspaces', `${workspace}.yml`));
+        const { data, found } = await load(workspacePath);
+        if (found) {
+            const workspace$ = WorkspaceSchema.safeParse(data);
+            if (!workspace$.success) {
+                return {
+                    error: workspace$.error.message,
+                    found: true,
+                    hasError: true,
+                };
+            }
+            return {
+                found: true,
+                hasError: false,
+                workspace: workspace$.data,
+            };
+        }
+        return {
+            found: false,
+        };
+    }
+    async getWorkspaceEnv(input) {
+        const workspace$ = await this.getWorkspace(input.workspace);
+        if (!workspace$.found) {
+            return {
+                reason: `Workspace ${input.workspace} not found`,
+                success: false,
+            };
+        }
+        if (workspace$.hasError) {
+            return {
+                reason: workspace$.error,
+                success: false,
+            };
+        }
+        return {
+            env: await resolveEnvValues(workspace$.workspace.env ?? {}),
+            success: true,
+        };
+    }
+    async init(options) {
+        return {
+            project: {
+                id: options.project,
+                name: options.project,
+            },
+            workspace: {
+                id: options.workspace,
+                name: options.workspace,
+            },
+        };
+    }
+    async removePackageFromWorkspace(input) {
+        const workspace$ = await this.getWorkspace(input.workspace);
+        if (!workspace$.found) {
+            return {
+                reason: `Workspace ${input.workspace} not found`,
+                success: false,
+            };
+        }
+        if (workspace$.hasError) {
+            return {
+                reason: workspace$.error,
+                success: false,
+            };
+        }
+        const { workspace } = workspace$;
+        workspace.packages = Object.fromEntries(Object.entries(workspace.packages ?? {})
+            .filter(([key]) => key !== input.package));
+        workspace.env = Object.fromEntries(Object.entries(workspace.env ?? {})
+            .filter(([key]) => !(key in input.env)));
+        try {
+            await this.saveWorkspace(workspace, input.workspace);
+            return {
+                success: true,
+                workspace,
+            };
+        }
+        catch (error) {
+            return {
+                reason: error.message,
+                success: false,
+            };
+        }
+    }
+    async saveState(config) {
+        const projectStatePath = await this.getProjectStatePath(config.project);
+        await save(config, projectStatePath);
+    }
+    async getProjectStatePath(project) {
+        return getAnyPath(path.join(os.homedir(), '.hereya', 'state', 'projects', `${project}.yaml`), path.join(os.homedir(), '.hereya', 'state', 'projects', `${project}.yml`));
+    }
+    async getWorkspacePath(name) {
+        return getAnyPath(path.join(os.homedir(), '.hereya', 'state', 'workspaces', `${name}.yaml`), path.join(os.homedir(), '.hereya', 'state', 'workspaces', `${name}.yml`));
+    }
+    async saveWorkspace(data, name) {
+        const workspacePath = await this.getWorkspacePath(name);
+        await save(data, workspacePath);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Add 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>;
+        parameter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/add/index.js

@@ -0,0 +1,96 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getBackend } from '../../backend/index.js';
+import { 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 { arrayOfStringToObject } from '../../lib/object-utils.js';
+import { getParameterManager } from '../../lib/parameter/index.js';
+export default class Add 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 project.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> cloudy/docker_postgres',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'directory to run command in',
+            required: false,
+        }),
+        parameter: Flags.string({
+            char: 'p',
+            default: [],
+            description: 'parameter for the package, in the form of \'key=value\'. Can be specified multiple times.',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        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 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 userSpecifiedParameters = arrayOfStringToObject(flags.parameter);
+        const parameterManager = getParameterManager();
+        const { parameters } = await parameterManager.getPackageParameters({
+            package: args.package,
+            projectRootDir,
+            userSpecifiedParameters,
+            workspace: config.workspace,
+        });
+        const provisionOutput = await provisionPackage({
+            env: workspaceEnv,
+            package: args.package,
+            parameters,
+            project: config.project,
+            workspace: config.workspace,
+        });
+        if (!provisionOutput.success) {
+            this.error(provisionOutput.reason);
+        }
+        const { env, metadata } = provisionOutput;
+        this.log(`Package ${args.package} added successfully`);
+        this.log(`Saving exported environment variables`);
+        const envManager = getEnvManager();
+        await envManager.addProjectEnv({
+            env,
+            infra: metadata.infra,
+            projectRootDir,
+            workspace: config.workspace,
+        });
+        await configManager.addPackage({
+            package: args.package,
+            projectRootDir,
+        });
+        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+        await backend.saveState(newConfig);
+        const { filePath, saved } = await parameterManager.savePackageParameters({
+            package: args.package,
+            parameters,
+            projectRootDir,
+            workspace: config.workspace,
+        });
+        if (saved) {
+            this.log(`Saved the following parameters for the package in ${filePath}:`);
+            logEnv(parameters, this.log.bind(this));
+        }
+    }
+}

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

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

package/dist/commands/bootstrap/index.js

@@ -0,0 +1,28 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getInfrastructure } from '../../infrastructure/index.js';
+export default class Bootstrap extends Command {
+    static args = {
+        infrastructureType: Args.string({
+            description: 'infrastructure to bootstrap. Options are local, aws, azure, gcp',
+            required: true
+        })
+    };
+    static description = 'Install necessary resources for hereya operations in an infrastructure.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> aws',
+        '<%= config.bin %> <%= command.id %> local'
+    ];
+    static flags = {
+        force: Flags.boolean({ char: 'f', description: 'redeploy hereya resources if already deployed' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Bootstrap);
+        const infrastructure$ = getInfrastructure({ type: args.infrastructureType });
+        if (!infrastructure$.supported) {
+            this.warn(infrastructure$.reason);
+            return;
+        }
+        const { infrastructure } = infrastructure$;
+        await infrastructure.bootstrap({ force: flags.force });
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Down 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/down/index.js

@@ -0,0 +1,78 @@
+import { 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 Down extends Command {
+    static description = 'Destroy 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(Down);
+        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 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);
+        }
+        const { env: workspaceEnv } = getWorkspaceEnvOutput;
+        const parameterManager = getParameterManager();
+        const result = await Promise.all(packages.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 envManager = getEnvManager();
+        for (const { env, metadata } of result) {
+            // eslint-disable-next-line no-await-in-loop
+            await envManager.removeProjectEnv({
+                env,
+                infra: metadata.infra,
+                projectRootDir,
+                workspace,
+            });
+        }
+        const { config: newConfig } = await configManager.loadConfig({ projectRootDir });
+        await backend.saveState(newConfig);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Env 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/env/index.js

@@ -0,0 +1,46 @@
+import { Command, Flags } from '@oclif/core';
+import { getConfigManager } from '../../lib/config/index.js';
+import { getEnvManager } from '../../lib/env/index.js';
+import { logEnv } from '../../lib/env-utils.js';
+export default class Env extends Command {
+    static description = 'Print project environment variables.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -w dev',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'project root directory',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'name of the workspace to print the env vars for',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Env);
+        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 print the env vars for');
+        }
+        const envManager = getEnvManager();
+        const { env } = await envManager.getProjectEnv({
+            projectRootDir,
+            workspace,
+        });
+        logEnv(env);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static args: {
+        project: 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, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/init/index.js

@@ -0,0 +1,46 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getBackend } from '../../backend/index.js';
+import { getConfigManager } from '../../lib/config/index.js';
+export default class Init extends Command {
+    static args = {
+        project: Args.string({ description: 'project name', required: true }),
+    };
+    static description = 'Initialize hereya in a project directory.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> myProject -w=defaultWorkspace',
+        '<%= config.bin %> <%= command.id %> myProject -w=defaultWorkspace --chdir=./myProject',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: 'directory to run command in',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'workspace to set as default',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Init);
+        const projectRootDir = flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR;
+        const configManager = getConfigManager();
+        const config$ = await configManager.loadConfig({ projectRootDir });
+        if (config$.found) {
+            this.warn(`Project already initialized.`);
+            return;
+        }
+        const backend = await getBackend();
+        const initProjectOutput = await backend.init({
+            project: args.project,
+            workspace: flags.workspace,
+        });
+        const content = {
+            project: initProjectOutput.project.id,
+            workspace: initProjectOutput.workspace.name,
+        };
+        await configManager.saveConfig({ config: content, projectRootDir });
+        this.log(`Initialized project ${initProjectOutput.project.name}.`);
+        this.log(`Current workspace set to ${initProjectOutput.workspace.name}.`);
+    }
+}

package/dist/commands/remote/exec/index.d.ts

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

package/dist/commands/remote/exec/index.js

@@ -0,0 +1,65 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getIac } from '../../../iac/index.js';
+import { getInfrastructure } from '../../../infrastructure/index.js';
+import { save } from '../../../lib/yaml-utils.js';
+export default class RemoteExec extends Command {
+    static args = {
+        pkgPath: Args.string({
+            description: 'The path to the package to provision or destroy',
+            required: false,
+        }),
+    };
+    static description = 'remotely provision or destroy a package';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        output: Flags.string({
+            char: 'o',
+            description: 'The path to store the output env in',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RemoteExec);
+        const workspaceEnv = Object.fromEntries((process.env.HEREYA_WORKSPACE_ENV?.split(',') ?? []).map(param => param.split('=')));
+        const parameters = Object.fromEntries((process.env.HEREYA_PARAMETERS?.split(',') ?? []).map(param => param.split('=')));
+        const id = process.env.HEREYA_ID;
+        const iacType = process.env.HEREYA_IAC_TYPE;
+        const destroy = process.env.HEREYA_DESTROY === 'true';
+        const infraType = process.env.HEREYA_INFRA_TYPE;
+        if (!id || !iacType || !infraType) {
+            return this.error(`
+                Missing required environment variables:
+                HEREYA_ID: ${id}
+                HEREYA_IAC_TYPE: ${iacType}
+                HEREYA_INFRA_TYPE: ${infraType}
+            `);
+        }
+        const input = {
+            env: workspaceEnv, id, parameters, pkgPath: args.pkgPath || process.cwd(),
+        };
+        const iac$ = getIac({ type: iacType });
+        if (!iac$.supported) {
+            return this.error(iac$.reason);
+        }
+        const { iac } = iac$;
+        const output = await (destroy ? iac.destroy(input) : iac.apply(input));
+        if (!output.success) {
+            return this.error(output.reason);
+        }
+        if (flags.output) {
+            await save(output.env, flags.output);
+            this.log(`Output env saved to ${flags.output}`);
+        }
+        const infra$ = getInfrastructure({ type: infraType });
+        if (!infra$.supported) {
+            return this.error(infra$.reason);
+        }
+        const { infrastructure } = infra$;
+        const saveOutput = await infrastructure.saveEnv({ env: output.env, id });
+        if (!saveOutput.success) {
+            return this.error(saveOutput.reason);
+        }
+    }
+}