hereya-cli 0.30.0 → 0.32.0

package/dist/backend/local.js

@@ -1,379 +1,9 @@
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { getAnyPath } from '../lib/filesystem.js';
-import { load, save } from '../lib/yaml-utils.js';
-import { WorkspaceSchema, } from './common.js';
-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$;
-        if (workspace.mirrorOf) {
-            return {
-                reason: `Cannot add package to mirrored workspace ${input.workspace}`,
-                success: false,
-            };
-        }
-        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,
-                };
-        }
-        if (input.mirrorOf) {
-            const mirroredWorkspace$ = await this.getWorkspace(input.mirrorOf);
-            if (!mirroredWorkspace$.found) {
-                return {
-                    reason: `Mirrored workspace ${input.mirrorOf} not found`,
-                    success: false,
-                };
-            }
-            if (mirroredWorkspace$.hasError) {
-                return {
-                    reason: mirroredWorkspace$.error,
-                    success: false,
-                };
-            }
-        }
-        const workspace = {
-            id: input.name,
-            mirrorOf: input.mirrorOf,
-            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$;
-        const workspaceNames = await this.listWorkspaces();
-        const allWorkspaces = await Promise.all(workspaceNames.map(async (workspaceName) => {
-            const w$ = await this.getWorkspace(workspaceName);
-            if (!w$.found || w$.hasError) {
-                throw new Error(`Workspace ${workspaceName} not found or has an error`);
-            }
-            return w$.workspace;
-        }));
-        if (allWorkspaces.some((w) => w.mirrorOf === input.name)) {
-            return {
-                reason: `Cannot delete workspace ${input.name} because it is mirrored by ${allWorkspaces
-                    .filter((w) => w.mirrorOf === input.name)
-                    .map((w) => w.name)
-                    .join(', ')}`,
-                success: false,
-            };
-        }
-        if (!workspace.mirrorOf && 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 getProvisioningId(input) {
-        const idFilePath = await getAnyPath(path.join(os.homedir(), '.hereya', 'provisioning', `${input.logicalId}.yaml`), path.join(os.homedir(), '.hereya', 'provisioning', `${input.logicalId}.yml`));
-        const { data, found } = await load(idFilePath);
-        if (!found || !data.id) {
-            data.id = `p-${randomUUID()}`;
-            await save(data, idFilePath);
-        }
-        return {
-            id: data.id,
-            success: true,
-        };
-    }
-    async getState(input) {
-        const projectStatePath = await this.getProjectStatePath(input);
-        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, error, found } = await load(workspacePath);
-        if (error) {
-            return {
-                error,
-                found: true,
-                hasError: true,
-            };
-        }
-        if (!found) {
-            return {
-                found: false,
-            };
-        }
-        const workspace$ = WorkspaceSchema.safeParse(data);
-        if (!workspace$.success) {
-            return {
-                error: workspace$.error.message,
-                found: true,
-                hasError: true,
-            };
-        }
-        let mirroredWorkspace;
-        if (workspace$.data.mirrorOf) {
-            const mirroredWorkspace$ = await this.getWorkspace(workspace$.data.mirrorOf);
-            if (!mirroredWorkspace$.found) {
-                return {
-                    error: `Mirrored workspace ${workspace$.data.mirrorOf} not found`,
-                    found: true,
-                    hasError: true,
-                };
-            }
-            if (mirroredWorkspace$.hasError) {
-                return {
-                    error: mirroredWorkspace$.error,
-                    found: true,
-                    hasError: true,
-                };
-            }
-            mirroredWorkspace = mirroredWorkspace$.workspace;
-        }
-        return {
-            found: true,
-            hasError: false,
-            workspace: mirroredWorkspace
-                ? {
-                    ...workspace$.data,
-                    env: {
-                        ...mirroredWorkspace.env,
-                        ...workspace$.data.env,
-                    },
-                    packages: {
-                        ...mirroredWorkspace.packages,
-                    },
-                }
-                : {
-                    ...workspace$.data,
-                    packages: {
-                        ...workspace$.data.packages,
-                    },
-                },
-        };
-    }
-    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: workspace$.workspace.env ?? {},
-            success: true,
-        };
-    }
-    async init(options) {
-        return {
-            project: {
-                id: options.project,
-                name: options.project,
-            },
-            workspace: {
-                id: options.workspace,
-                name: options.workspace,
-            },
-        };
-    }
-    async listWorkspaces() {
-        const workspacesPath = path.join(os.homedir(), '.hereya', 'state', 'workspaces');
-        const workspaces = await fs.readdir(workspacesPath);
-        return workspaces.map((workspace) => workspace.replace(/\.yaml|\.yml$/, '')).sort();
-    }
-    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$;
-        if (workspace.mirrorOf) {
-            return {
-                reason: `Cannot remove package from mirrored workspace ${input.workspace}`,
-                success: false,
-            };
-        }
-        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, workspace) {
-        const projectStatePath = await this.getProjectStatePath({
-            project: config.project,
-            workspace: workspace ?? config.workspace,
-        });
-        await save({ ...config, workspace: workspace ?? config.workspace }, projectStatePath);
-    }
-    async setEnvVar(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.env = {
-            ...workspace.env,
-            [input.name]: input.value,
-        };
-        await this.saveWorkspace(workspace, input.workspace);
-        return {
-            success: true,
-        };
-    }
-    async unsetEnvVar(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$;
-        const value = workspace.env?.[input.name];
-        if (!value) {
-            return {
-                success: true,
-            };
-        }
-        workspace.env = Object.fromEntries(Object.entries(workspace.env ?? {}).filter(([key]) => key !== input.name));
-        await this.saveWorkspace(workspace, input.workspace);
-        return {
-            success: true,
-        };
-    }
-    async getProjectStatePath(input) {
-        return getAnyPath(path.join(os.homedir(), '.hereya', 'state', 'projects', input.workspace, `${input.project}.yaml`), path.join(os.homedir(), '.hereya', 'state', 'projects', input.workspace, `${input.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);
+import { LocalFileStorage } from './file-storage/local.js';
+import { FileBackend } from './file.js';
+export class LocalFileBackend extends FileBackend {
+    constructor(basePath = path.join(os.homedir(), '.hereya')) {
+        super(new LocalFileStorage(basePath));
     }
 }

package/dist/backend/s3.d.ts

@@ -0,0 +1,4 @@
+import { FileBackend } from "./file.js";
+export declare class S3FileBackend extends FileBackend {
+    constructor(bucket: string, basePath?: string);
+}

package/dist/backend/s3.js

@@ -0,0 +1,7 @@
+import { S3FileStorage } from "./file-storage/s3.js";
+import { FileBackend } from "./file.js";
+export class S3FileBackend extends FileBackend {
+    constructor(bucket, basePath = '') {
+        super(new S3FileStorage(bucket, basePath));
+    }
+}

package/dist/commands/config/get-backend/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class ConfigGetBackend extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/get-backend/index.js

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import { getCurrentBackendType } from '../../../backend/config.js';
+export default class ConfigGetBackend extends Command {
+    static description = 'get the current backend type';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const backendType = await getCurrentBackendType();
+        this.log(backendType);
+    }
+}

package/dist/commands/config/use-backend/index.d.ts

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

package/dist/commands/config/use-backend/index.js

@@ -0,0 +1,20 @@
+import { Args, Command } from '@oclif/core';
+import { setBackendType } from '../../../backend/config.js';
+export default class ConfigUseBackend extends Command {
+    static args = {
+        type: Args.string({ description: 'type of backend to use. Possible values: s3, local', required: true }),
+    };
+    static description = 'set the current backend type';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> s3',
+        '<%= config.bin %> <%= command.id %> local',
+    ];
+    async run() {
+        const { args } = await this.parse(ConfigUseBackend);
+        const { type } = args;
+        if (type !== 's3' && type !== 'local') {
+            this.error('Invalid backend type. Possible values: s3, local');
+        }
+        await setBackendType(type);
+    }
+}

package/dist/infrastructure/aws-config.d.ts

@@ -0,0 +1,7 @@
+export declare function getAwsConfigKey(): string;
+export declare function getAwsConfig(): Promise<{
+    backendBucket: string;
+    terraformStateBucketName: string;
+    terraformStateBucketRegion?: string;
+    terraformStateLockTableName: string;
+}>;

package/dist/infrastructure/aws-config.js

@@ -0,0 +1,12 @@
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+const configKey = '/hereya-bootstrap/config';
+export function getAwsConfigKey() {
+    return configKey;
+}
+export async function getAwsConfig() {
+    const ssmClient = new SSMClient({});
+    const ssmParameter = await ssmClient.send(new GetParameterCommand({
+        Name: configKey,
+    }));
+    return JSON.parse(ssmParameter.Parameter?.Value ?? '{}');
+}

package/dist/infrastructure/aws.d.ts

@@ -1,6 +1,5 @@
 import { BootstrapInput, DeployInput, DeployOutput, DestroyInput, DestroyOutput, Infrastructure, ProvisionInput, ProvisionOutput, ResolveEnvInput, ResolveEnvOutput, SaveEnvInput, SaveEnvOutput, StoreEnvInput, StoreEnvOutput, UndeployInput, UndeployOutput, UnstoreEnvInput, UnstoreEnvOutput } from './common.js';
 export declare class AwsInfrastructure implements Infrastructure {
-    private configKey;
     bootstrap(_: BootstrapInput): Promise<void>;
     deploy(input: DeployInput): Promise<DeployOutput>;
     destroy(input: DestroyInput): Promise<DestroyOutput>;
@@ -11,5 +10,4 @@ export declare class AwsInfrastructure implements Infrastructure {
     unbootstrap(_: BootstrapInput): Promise<void>;
     undeploy(input: UndeployInput): Promise<UndeployOutput>;
     unstoreEnv(input: UnstoreEnvInput): Promise<UnstoreEnvOutput>;
-    private getConfig;
 }

package/dist/infrastructure/aws.js

@@ -3,14 +3,28 @@ import { DeleteParameterCommand, GetParameterCommand, PutParameterCommand, SSMCl
 import { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts';
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import { getIac } from '../iac/index.js';
 import { downloadPackage } from '../lib/package/index.js';
 import { runShell } from '../lib/shell.js';
+import { getAwsConfig, getAwsConfigKey } from './aws-config.js';
+import { getPackageDownloadPath } from './common.js';
 import { destroyPackage, provisionPackage } from './index.js';
 export class AwsInfrastructure {
-    configKey = '/hereya-bootstrap/config';
+    // public static configKey = '/hereya-bootstrap/config'
+    // public static async getConfig(): Promise<{
+    //   backendBucket: string
+    //   terraformStateBucketName: string
+    //   terraformStateBucketRegion?: string
+    //   terraformStateLockTableName: string
+    // }> {
+    //   const ssmClient = new SSMClient({})
+    //   const ssmParameter = await ssmClient.send(
+    //     new GetParameterCommand({
+    //       Name: AwsInfrastructure.configKey,
+    //     }),
+    //   )
+    //   return JSON.parse(ssmParameter.Parameter?.Value ?? '{}')
+    // }
     async bootstrap(_) {
         const stsClient = new STSClient({});
         const { Account: accountId } = await stsClient.send(new GetCallerIdentityCommand({}));
@@ -22,7 +36,7 @@ export class AwsInfrastructure {
             throw new Error(output.reason);
         }
         const { env } = output;
-        const key = this.configKey;
+        const key = getAwsConfigKey();
         const ssmClient = new SSMClient({});
         const value = JSON.stringify(env);
         await ssmClient.send(new PutParameterCommand({
@@ -41,11 +55,11 @@ export class AwsInfrastructure {
         return this.provision(input);
     }
     async destroy(input) {
-        const destPath = path.join(os.homedir(), '.hereya', input.id, input.canonicalName);
+        const destPath = await getPackageDownloadPath(input);
         const downloadPath = await downloadPackage(input.pkgUrl, destPath);
         const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
         const infraConfig = {
-            ...await this.getConfig(),
+            ...await getAwsConfig(),
             region,
         };
         if (!infraConfig.terraformStateBucketName || !infraConfig.terraformStateLockTableName) {
@@ -75,9 +89,9 @@ export class AwsInfrastructure {
         return { env: output.env, success: true };
     }
     async provision(input) {
-        const destPath = path.join(os.homedir(), '.hereya', input.id, input.canonicalName);
+        const destPath = await getPackageDownloadPath(input);
         const downloadPath = await downloadPackage(input.pkgUrl, destPath);
-        const config = await this.getConfig();
+        const config = await getAwsConfig();
         const terraformStateBucketRegion = config.terraformStateBucketRegion || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
         const infraConfig = {
             ...config,
@@ -220,11 +234,4 @@ export class AwsInfrastructure {
         }));
         return { success: true };
     }
-    async getConfig() {
-        const ssmClient = new SSMClient({});
-        const ssmParameter = await ssmClient.send(new GetParameterCommand({
-            Name: this.configKey,
-        }));
-        return JSON.parse(ssmParameter.Parameter?.Value ?? '{}');
-    }
 }

package/dist/infrastructure/common.d.ts

@@ -18,6 +18,9 @@ export interface Infrastructure {
     undeploy(input: UndeployInput): Promise<UndeployOutput>;
     unstoreEnv(input: UnstoreEnvInput): Promise<UnstoreEnvOutput>;
 }
+export declare function getPackageDownloadPath(input: {
+    id: string;
+}): Promise<string>;
 export type BootstrapInput = {
     force?: boolean;
 };

package/dist/infrastructure/common.js

@@ -1,3 +1,5 @@
+import os from 'node:os';
+import path from 'node:path';
 export var InfrastructureType;
 (function (InfrastructureType) {
     InfrastructureType["aws"] = "aws";
@@ -5,3 +7,6 @@ export var InfrastructureType;
     InfrastructureType["gcp"] = "gcp";
     InfrastructureType["local"] = "local";
 })(InfrastructureType || (InfrastructureType = {}));
+export async function getPackageDownloadPath(input) {
+    return path.join(os.homedir(), '.hereya', 'packages', input.id);
+}

package/dist/infrastructure/local.js

@@ -1,8 +1,7 @@
 import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import path from 'node:path';
 import { getIac } from '../iac/index.js';
 import { downloadPackage } from '../lib/package/index.js';
+import { getPackageDownloadPath, } from './common.js';
 export class LocalInfrastructure {
     async bootstrap() {
         console.log('Bootstrapping local infrastructure');
@@ -16,8 +15,7 @@ export class LocalInfrastructure {
         return this.provision(input);
     }
     async destroy(input) {
-        // noinspection DuplicatedCode
-        const destPath = path.join(os.homedir(), '.hereya', 'packages', input.id);
+        const destPath = await getPackageDownloadPath(input);
         const downloadPath = await downloadPackage(input.pkgUrl, destPath);
         const iac$ = getIac({ type: input.iacType });
         if (!iac$.supported) {
@@ -39,8 +37,7 @@ export class LocalInfrastructure {
         return { env: output.env, success: true };
     }
     async provision(input) {
-        // noinspection DuplicatedCode
-        const destPath = path.join(os.homedir(), '.hereya', 'packages', input.id);
+        const destPath = await getPackageDownloadPath(input);
         const downloadPath = await downloadPackage(input.pkgUrl, destPath);
         const iac$ = getIac({ type: input.iacType });
         if (!iac$.supported) {

package/dist/lib/yaml-utils.d.ts

@@ -4,3 +4,7 @@ export declare function load<T extends object>(file: string): Promise<{
     error?: string;
     found: boolean;
 }>;
+export declare function parseYaml<T extends object>(content: string): Promise<{
+    data: T;
+    error?: string;
+}>;

package/dist/lib/yaml-utils.js

@@ -11,17 +11,24 @@ export async function save(content, file) {
     }
 }
 export async function load(file) {
-    let data = {};
-    let found = false;
     try {
         const content = await readFile(file, { encoding: 'utf8' });
-        data = parse(content);
-        found = true;
+        const { data, error } = await parseYaml(content);
+        return { data, error, found: true };
     }
     catch (error) {
         if (error.code !== 'ENOENT') {
             return { data: {}, error: `could not load file ${file}: ${error}`, found: true };
         }
+        return { data: {}, found: false };
+    }
+}
+export async function parseYaml(content) {
+    try {
+        const data = parse(content);
+        return { data };
+    }
+    catch (error) {
+        return { data: {}, error: `could not parse yaml: ${error}` };
     }
-    return { data: data || {}, found };
 }