hereya-cli 0.2.1

package/dist/iac/cdk.js

@@ -0,0 +1,83 @@
+import { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { runShell } from '../lib/shell.js';
+import { load } from '../lib/yaml-utils.js';
+export class Cdk {
+    async apply(input) {
+        try {
+            const parameterNames = await this.getParameterNames(input.pkgPath);
+            const serializedWorkspaceEnv = Object.entries(input.env)
+                .filter(([key]) => parameterNames.includes(key))
+                .flatMap(([key, value]) => ['--parameters', `${key}=${value}`]);
+            const serializedParameters = Object.entries(input.parameters ?? {})
+                .filter(([key]) => parameterNames.includes(key))
+                .flatMap(([key, value]) => ['--parameters', `${key}=${value}`]);
+            runShell('npx', [
+                'cdk', 'deploy', '--require-approval', 'never', ...serializedWorkspaceEnv, ...serializedParameters,
+            ], {
+                directory: input.pkgPath,
+                env: { STACK_NAME: input.id },
+            });
+            const env = await this.getEnv(input.id);
+            return { env, success: true };
+        }
+        catch (error) {
+            return { reason: error.message, success: false };
+        }
+    }
+    async destroy(input) {
+        try {
+            const env = await this.getEnv(input.id);
+            const parameterNames = await this.getParameterNames(input.pkgPath);
+            const serializedWorkspaceEnv = Object.entries(input.env)
+                .filter(([key]) => parameterNames.includes(key))
+                .flatMap(([key, value]) => ['--parameters', `${key}=${value}`]);
+            const serializedParameters = Object.entries(input.parameters ?? {})
+                .filter(([key]) => parameterNames.includes(key))
+                .flatMap(([key, value]) => ['--parameters', `${key}=${value}`]);
+            runShell('npx', [
+                'cdk', 'destroy', '--force', ...serializedWorkspaceEnv, ...serializedParameters,
+            ], {
+                directory: input.pkgPath,
+                env: { STACK_NAME: input.id }
+            });
+            return { env, success: true };
+        }
+        catch (error) {
+            return { reason: error.message, success: false };
+        }
+    }
+    async getEnv(stackName) {
+        const stack = await this.getStack(stackName);
+        const env = {};
+        for (const output of stack?.Outputs?.filter(output => output.OutputKey) ?? []) {
+            env[output.OutputKey] = output.OutputValue;
+        }
+        return env;
+    }
+    async getParameterNames(workDir) {
+        runShell('npm', ['install'], { directory: workDir });
+        const result = runShell('npx', [
+            'cdk', 'synth',
+        ], {
+            directory: workDir,
+            stdio: 'pipe'
+        });
+        const stackYamlPath = path.join(workDir, '.stack.yaml');
+        writeFileSync(stackYamlPath, result.stdout);
+        const { data: synthedStack } = await load(stackYamlPath);
+        return Object.keys(synthedStack.Parameters);
+    }
+    async getStack(stackName) {
+        const cfnClient = new CloudFormationClient({});
+        const response = await cfnClient.send(new DescribeStacksCommand({
+            StackName: stackName,
+        }));
+        const stack = response.Stacks?.[0];
+        if (!stack) {
+            throw new Error(`Stack ${stackName} not found`);
+        }
+        return stack;
+    }
+}

package/dist/iac/common.d.ts

@@ -0,0 +1,29 @@
+export interface Iac {
+    apply(input: ApplyInput): Promise<ApplyOutput>;
+    destroy(input: DestroyInput): Promise<DestroyOutput>;
+}
+export declare enum IacType {
+    cdk = "cdk",
+    terraform = "terraform"
+}
+export type ApplyInput = {
+    env: {
+        [key: string]: string;
+    };
+    id: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    pkgPath: string;
+};
+export type ApplyOutput = {
+    env: {
+        [key: string]: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type DestroyInput = ApplyInput;
+export type DestroyOutput = ApplyOutput;

package/dist/iac/common.js

@@ -0,0 +1,5 @@
+export var IacType;
+(function (IacType) {
+    IacType["cdk"] = "cdk";
+    IacType["terraform"] = "terraform";
+})(IacType || (IacType = {}));

package/dist/iac/index.d.ts

@@ -0,0 +1,16 @@
+import { Cdk } from './cdk.js';
+import { Iac, IacType } from './common.js';
+import { Terraform } from './terraform.js';
+export declare const terraform: Terraform;
+export declare const cdk: Cdk;
+export declare function getIac({ type }: GetIacInput): GetIacOutput;
+export type GetIacInput = {
+    type: IacType;
+};
+export type GetIacOutput = {
+    iac: Iac;
+    supported: true;
+} | {
+    reason: string;
+    supported: false;
+};

package/dist/iac/index.js

@@ -0,0 +1,18 @@
+import { Cdk } from './cdk.js';
+import { IacType } from './common.js';
+import { Terraform } from './terraform.js';
+export const terraform = new Terraform();
+export const cdk = new Cdk();
+export function getIac({ type }) {
+    switch (type) {
+        case IacType.terraform: {
+            return { iac: terraform, supported: true };
+        }
+        case IacType.cdk: {
+            return { iac: cdk, supported: true };
+        }
+        default: {
+            return { reason: `Iac type ${type} is not supported yet!`, supported: false };
+        }
+    }
+}

package/dist/iac/terraform.d.ts

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

package/dist/iac/terraform.js

@@ -0,0 +1,67 @@
+import { mapObject } from '../lib/object-utils.js';
+import { runShell } from '../lib/shell.js';
+export class Terraform {
+    async apply(input) {
+        try {
+            runShell('terraform', ['init'], {
+                directory: input.pkgPath,
+                env: Object.assign(input.env, mapObject(input.parameters ?? {}, (key, value) => [`TF_VAR_${key}`, value]))
+            });
+            runShell('terraform', ['apply', '-auto-approve'], {
+                directory: input.pkgPath,
+                env: Object.assign(input.env, mapObject(input.parameters ?? {}, (key, value) => [`TF_VAR_${key}`, value]))
+            });
+            const env = await this.getEnv(input.pkgPath);
+            return {
+                env,
+                success: true
+            };
+        }
+        catch (error) {
+            return {
+                reason: error.message,
+                success: false
+            };
+        }
+    }
+    async destroy(input) {
+        const applyOutput = await this.apply(input);
+        if (!applyOutput.success) {
+            return applyOutput;
+        }
+        const { env } = applyOutput;
+        try {
+            runShell('terraform', ['destroy', '-auto-approve'], {
+                directory: input.pkgPath,
+                env: Object.assign(input.env, mapObject(input.parameters ?? {}, (key, value) => [`TF_VAR_${key}`, value]))
+            });
+            return {
+                env,
+                success: true
+            };
+        }
+        catch (error) {
+            return {
+                reason: error.message,
+                success: false
+            };
+        }
+    }
+    async getEnv(pkgPath) {
+        const resourceOut = runShell('terraform', ['output', '--json'], {
+            directory: pkgPath,
+            stdio: 'pipe'
+        });
+        let outStr = resourceOut.output.toString().trim();
+        const start = outStr.indexOf('{');
+        const end = outStr.lastIndexOf('}');
+        outStr = outStr.slice(start, end + 1);
+        const tfEnvObj = JSON.parse(outStr);
+        const tfEnv = {};
+        // eslint-disable-next-line guard-for-in
+        for (const key in tfEnvObj) {
+            tfEnv[key] = tfEnvObj[key].value;
+        }
+        return tfEnv;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/infrastructure/aws.d.ts

@@ -0,0 +1,8 @@
+import { BootstrapInput, DestroyInput, DestroyOutput, Infrastructure, ProvisionInput, ProvisionOutput, ResolveEnvInput, ResolveEnvOutput, SaveEnvInput, SaveEnvOutput } from './common.js';
+export declare class AwsInfrastructure implements Infrastructure {
+    bootstrap(_: BootstrapInput): Promise<void>;
+    destroy(_: DestroyInput): Promise<DestroyOutput>;
+    provision(_: ProvisionInput): Promise<ProvisionOutput>;
+    resolveEnv(_: ResolveEnvInput): Promise<ResolveEnvOutput>;
+    saveEnv(_: SaveEnvInput): Promise<SaveEnvOutput>;
+}

package/dist/infrastructure/aws.js

@@ -0,0 +1,28 @@
+import { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts';
+import { runShell } from '../lib/shell.js';
+import { provisionPackage } from './index.js';
+export class AwsInfrastructure {
+    async bootstrap(_) {
+        const stsClient = new STSClient({});
+        const { Account: accountId } = await stsClient.send(new GetCallerIdentityCommand({}));
+        const region = process.env.AWS_REGION;
+        runShell('npx', ['cdk', 'bootstrap', `aws://${accountId}/${region}`]);
+        const bootstrapPackage = 'hereya/bootstrap-aws-stack';
+        const output = await provisionPackage({ package: bootstrapPackage });
+        if (!output.success) {
+            throw new Error(output.reason);
+        }
+    }
+    async destroy(_) {
+        throw new Error('Method not implemented.');
+    }
+    async provision(_) {
+        throw new Error('Method not implemented.');
+    }
+    async resolveEnv(_) {
+        throw new Error('Method not implemented.');
+    }
+    async saveEnv(_) {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/infrastructure/common.d.ts

@@ -0,0 +1,59 @@
+import { IacType } from '../iac/common.js';
+export declare enum InfrastructureType {
+    aws = "aws",
+    azure = "azure",
+    gcp = "gcp",
+    local = "local"
+}
+export interface Infrastructure {
+    bootstrap(input: BootstrapInput): Promise<void>;
+    destroy(input: DestroyInput): Promise<DestroyOutput>;
+    provision(input: ProvisionInput): Promise<ProvisionOutput>;
+    resolveEnv(input: ResolveEnvInput): Promise<ResolveEnvOutput>;
+    saveEnv(input: SaveEnvInput): Promise<SaveEnvOutput>;
+}
+export type BootstrapInput = {
+    force?: boolean;
+};
+export type ProvisionInput = {
+    canonicalName: string;
+    env?: {
+        [key: string]: string;
+    };
+    iacType: IacType;
+    id: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    pkgName: string;
+    pkgUrl: string;
+};
+export type ProvisionOutput = {
+    env: {
+        [key: string]: string;
+    };
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type DestroyInput = ProvisionInput;
+export type DestroyOutput = ProvisionOutput;
+export type ResolveEnvInput = {
+    value: string;
+};
+export type ResolveEnvOutput = {
+    value: string;
+};
+export type SaveEnvInput = {
+    env: {
+        [key: string]: string;
+    };
+    id: string;
+};
+export type SaveEnvOutput = {
+    reason: string;
+    success: false;
+} | {
+    success: true;
+};

package/dist/infrastructure/common.js

@@ -0,0 +1,7 @@
+export var InfrastructureType;
+(function (InfrastructureType) {
+    InfrastructureType["aws"] = "aws";
+    InfrastructureType["azure"] = "azure";
+    InfrastructureType["gcp"] = "gcp";
+    InfrastructureType["local"] = "local";
+})(InfrastructureType || (InfrastructureType = {}));

package/dist/infrastructure/index.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { PackageMetadata } from '../lib/package/index.js';
+import { AwsInfrastructure } from './aws.js';
+import { Infrastructure, InfrastructureType } from './common.js';
+import { LocalInfrastructure } from './local.js';
+export declare const localInfrastructure: LocalInfrastructure;
+export declare const awsInfrastructure: AwsInfrastructure;
+export declare function getInfrastructure(input: GetInfrastructureInput): GetInfrastructureOutput;
+export declare function destroyPackage(input: DestroyPackageInput): Promise<DestroyPackageOutput>;
+export declare function provisionPackage(input: ProvisionPackageInput): Promise<ProvisionPackageOutput>;
+export type DestroyPackageInput = ProvisionPackageInput;
+export type DestroyPackageOutput = ProvisionPackageOutput;
+export type ProvisionPackageInput = {
+    env?: {
+        [key: string]: string;
+    };
+    package: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    project?: string;
+    workspace?: string;
+};
+export type ProvisionPackageOutput = {
+    env: {
+        [key: string]: string;
+    };
+    metadata: z.infer<typeof PackageMetadata>;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type GetInfrastructureInput = {
+    type: InfrastructureType;
+};
+export type GetInfrastructureOutput = {
+    reason: string;
+    supported: false;
+} | {
+    infrastructure: Infrastructure;
+    supported: true;
+};

package/dist/infrastructure/index.js

@@ -0,0 +1,82 @@
+import { resolvePackage } from '../lib/package/index.js';
+import { AwsInfrastructure } from './aws.js';
+import { InfrastructureType } from './common.js';
+import { LocalInfrastructure } from './local.js';
+export const localInfrastructure = new LocalInfrastructure();
+export const awsInfrastructure = new AwsInfrastructure();
+export function getInfrastructure(input) {
+    switch (input.type) {
+        case InfrastructureType.local: {
+            return {
+                infrastructure: localInfrastructure,
+                supported: true
+            };
+        }
+        case InfrastructureType.aws: {
+            return {
+                infrastructure: awsInfrastructure,
+                supported: true
+            };
+        }
+        default: {
+            return {
+                reason: `Infrastructure type ${input.type} is not supported yet!`,
+                supported: false
+            };
+        }
+    }
+}
+export async function destroyPackage(input) {
+    const resolvePackageOutput = await resolvePackage({ package: input.package });
+    if (!resolvePackageOutput.found) {
+        return { reason: resolvePackageOutput.reason, success: false };
+    }
+    const { canonicalName, metadata, packageUri } = resolvePackageOutput;
+    const infrastructure$ = getInfrastructure({ type: metadata.infra });
+    if (!infrastructure$.supported) {
+        return { reason: infrastructure$.reason, success: false };
+    }
+    const { infrastructure } = infrastructure$;
+    const destroyOutput = await infrastructure.destroy({
+        canonicalName,
+        env: input.env,
+        iacType: metadata.iac,
+        id: ((input.project || input.workspace) ? [input.project, input.workspace, canonicalName] : [canonicalName])
+            .filter(Boolean).join('')
+            .replaceAll(/[^\dA-Za-z]/g, ''),
+        parameters: input.parameters,
+        pkgName: input.package,
+        pkgUrl: packageUri,
+    });
+    if (!destroyOutput.success) {
+        return { reason: destroyOutput.reason, success: false };
+    }
+    return { env: destroyOutput.env, metadata, success: true };
+}
+export async function provisionPackage(input) {
+    const resolvePackageOutput = await resolvePackage({ package: input.package });
+    if (!resolvePackageOutput.found) {
+        return { reason: resolvePackageOutput.reason, success: false };
+    }
+    const { canonicalName, metadata, packageUri } = resolvePackageOutput;
+    const infrastructure$ = getInfrastructure({ type: metadata.infra });
+    if (!infrastructure$.supported) {
+        return { reason: infrastructure$.reason, success: false };
+    }
+    const { infrastructure } = infrastructure$;
+    const provisionOutput = await infrastructure.provision({
+        canonicalName,
+        env: input.env,
+        iacType: metadata.iac,
+        id: ((input.project || input.workspace) ? [input.project, input.workspace, canonicalName] : [canonicalName])
+            .filter(Boolean).join('')
+            .replaceAll(/[^\dA-Za-z]/g, ''),
+        parameters: input.parameters,
+        pkgName: input.package,
+        pkgUrl: packageUri,
+    });
+    if (!provisionOutput.success) {
+        return { reason: provisionOutput.reason, success: false };
+    }
+    return { env: provisionOutput.env, metadata, success: true };
+}

package/dist/infrastructure/local.d.ts

@@ -0,0 +1,14 @@
+import { Infrastructure, ProvisionInput, ProvisionOutput, SaveEnvInput, SaveEnvOutput } from './common.js';
+export declare class LocalInfrastructure implements Infrastructure {
+    bootstrap(): Promise<void>;
+    destroy(input: ProvisionInput): Promise<ProvisionOutput>;
+    provision(input: ProvisionInput): Promise<ProvisionOutput>;
+    resolveEnv(input: {
+        value: string;
+    }): Promise<{
+        value: string;
+    }>;
+    saveEnv(input: SaveEnvInput): Promise<SaveEnvOutput>;
+    private download;
+    private isNotEmpty;
+}

package/dist/infrastructure/local.js

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { simpleGit } from 'simple-git';
+import { getIac } from '../iac/index.js';
+export class LocalInfrastructure {
+    async bootstrap() {
+        console.log('Bootstrapping local infrastructure');
+    }
+    async destroy(input) {
+        // noinspection DuplicatedCode
+        const destPath = path.join(os.homedir(), '.hereya', input.id, input.canonicalName);
+        const downloadPath = await this.download(input.pkgUrl, destPath);
+        const iac$ = getIac({ type: input.iacType });
+        if (!iac$.supported) {
+            return { reason: iac$.reason, success: false };
+        }
+        const { iac } = iac$;
+        const output = await iac.destroy({
+            env: input.env ?? {},
+            id: input.id,
+            parameters: input.parameters,
+            pkgPath: downloadPath
+        });
+        if (!output.success) {
+            return { reason: output.reason, success: false };
+        }
+        // Remove downloaded package
+        await fs.rm(downloadPath, { recursive: true });
+        return { env: output.env, success: true };
+    }
+    async provision(input) {
+        // noinspection DuplicatedCode
+        const destPath = path.join(os.homedir(), '.hereya', input.id, input.canonicalName);
+        const downloadPath = await this.download(input.pkgUrl, destPath);
+        const iac$ = getIac({ type: input.iacType });
+        if (!iac$.supported) {
+            return { reason: iac$.reason, success: false };
+        }
+        const { iac } = iac$;
+        const output = await iac.apply({
+            env: input.env ?? {},
+            id: input.id,
+            parameters: input.parameters,
+            pkgPath: downloadPath
+        });
+        if (!output.success) {
+            return { reason: output.reason, success: false };
+        }
+        return { env: output.env, success: true };
+    }
+    async resolveEnv(input) {
+        return { value: input.value };
+    }
+    async saveEnv(input) {
+        console.log(`Saving env to ${input.id}`);
+        return { success: true };
+    }
+    async download(pkgUrl, destPath) {
+        if (await this.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
+        await git.clone(pkgUrl, destPath, ['--depth=1']);
+        return destPath;
+    }
+    async isNotEmpty(directoryPath) {
+        try {
+            const files = await fs.readdir(directoryPath);
+            return files.length > 0;
+        }
+        catch {
+            return false; // or you can handle the error as needed
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+export interface ConfigManager {
+    addPackage: (input: AddPackageInput) => Promise<void>;
+    loadConfig: (input: LoadConfigInput) => Promise<LoadConfigOutput>;
+    removePackage: (input: RemovePackageInput) => Promise<void>;
+    saveConfig: (input: SaveConfigInput) => Promise<void>;
+}
+export interface LoadConfigInput {
+    projectRootDir?: string;
+}
+export type LoadConfigOutput = {
+    config: Config;
+    found: false;
+} | {
+    config: Config;
+    found: true;
+};
+export interface Config {
+    packages?: {
+        [key: string]: {
+            version: string;
+        };
+    };
+    project: string;
+    workspace: string;
+}
+export interface SaveConfigInput {
+    config: Config;
+    projectRootDir?: string;
+}
+export type AddPackageInput = {
+    package: string;
+    projectRootDir?: string;
+};
+export type RemovePackageInput = AddPackageInput;

package/dist/lib/config/common.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/config/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigManager } from './common.js';
+export declare const configManager: ConfigManager;
+export declare function getConfigManager(): ConfigManager;

package/dist/lib/config/index.js

@@ -0,0 +1,5 @@
+import { SimpleConfigManager } from './simple.js';
+export const configManager = new SimpleConfigManager();
+export function getConfigManager() {
+    return configManager;
+}

package/dist/lib/config/simple.d.ts

@@ -0,0 +1,8 @@
+import { AddPackageInput, ConfigManager, LoadConfigInput, LoadConfigOutput, RemovePackageInput, SaveConfigInput } from './common.js';
+export declare class SimpleConfigManager implements ConfigManager {
+    addPackage(input: AddPackageInput): Promise<void>;
+    loadConfig(input: LoadConfigInput): Promise<LoadConfigOutput>;
+    removePackage(input: RemovePackageInput): Promise<void>;
+    saveConfig(input: SaveConfigInput): Promise<void>;
+    private getConfigPath;
+}

package/dist/lib/config/simple.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { getAnyPath } from '../filesystem.js';
+import * as yaml from '../yaml-utils.js';
+export class SimpleConfigManager {
+    async addPackage(input) {
+        const { config } = await this.loadConfig({ projectRootDir: input.projectRootDir });
+        await yaml.save({
+            ...config,
+            packages: {
+                ...config.packages,
+                [input.package]: {
+                    version: ''
+                }
+            },
+        }, await this.getConfigPath(input.projectRootDir));
+    }
+    async loadConfig(input) {
+        const configFilePath = await this.getConfigPath(input.projectRootDir);
+        const { data: config, found } = await yaml.load(configFilePath);
+        return {
+            config,
+            found,
+        };
+    }
+    async removePackage(input) {
+        const { config } = await this.loadConfig({ projectRootDir: input.projectRootDir });
+        const newPackages = { ...config.packages };
+        delete newPackages[input.package];
+        await yaml.save({
+            ...config,
+            packages: newPackages,
+        }, await this.getConfigPath(input.projectRootDir));
+    }
+    async saveConfig(input) {
+        const configFilePath = await this.getConfigPath(input.projectRootDir);
+        await yaml.save(input.config, configFilePath);
+    }
+    async getConfigPath(rootDir) {
+        return getAnyPath(path.join(rootDir ?? process.cwd(), 'hereya.yaml'), path.join(rootDir ?? process.cwd(), 'hereya.yml'));
+    }
+}