hereya-cli 0.31.0 → 0.32.0

package/dist/backend/file.js

@@ -0,0 +1,413 @@
+import { randomUUID } from 'node:crypto';
+import { stringify } from 'yaml';
+import { parseYaml } from '../lib/yaml-utils.js';
+import { WorkspaceSchema, } from './common.js';
+export class FileBackend {
+    fileStorage;
+    constructor(fileStorage) {
+        this.fileStorage = fileStorage;
+    }
+    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 result = await this.fileStorage.deleteFile({
+            paths: [`state/workspaces/${input.name}.yaml`, `state/workspaces/${input.name}.yml`],
+        });
+        if (result.success) {
+            return {
+                success: true,
+            };
+        }
+        return {
+            reason: result.error ?? '',
+            success: false,
+        };
+    }
+    async getProvisioningId(input) {
+        const idPaths = [`provisioning/${input.logicalId}.yaml`, `provisioning/${input.logicalId}.yml`];
+        const newId = `p-${randomUUID()}`;
+        const result = await this.fileStorage.getFileContent({ paths: idPaths });
+        if (!result.found) {
+            await this.fileStorage.saveFileContent({ content: stringify({ id: newId }), paths: idPaths });
+            return {
+                id: newId,
+                success: true,
+            };
+        }
+        const { data, error } = await parseYaml(result.content);
+        if (error || !data.id) {
+            await this.fileStorage.saveFileContent({ content: stringify({ id: newId }), paths: idPaths });
+            return {
+                id: newId,
+                success: true,
+            };
+        }
+        return {
+            id: data.id,
+            success: true,
+        };
+    }
+    async getState(input) {
+        const paths = [
+            ['state', 'projects', input.workspace, `${input.project}.yaml`].join('/'),
+            ['state', 'projects', input.workspace, `${input.project}.yml`].join('/'),
+        ];
+        const result = await this.fileStorage.getFileContent({ paths });
+        if (!result.found) {
+            return {
+                found: false,
+            };
+        }
+        const { data, error } = await parseYaml(result.content);
+        if (error) {
+            throw new Error(`Could not parse project state: ${error}`);
+        }
+        return {
+            config: data,
+            found: true,
+        };
+    }
+    async getWorkspace(workspace) {
+        const paths = [
+            ['state', 'workspaces', `${workspace}.yaml`].join('/'),
+            ['state', 'workspaces', `${workspace}.yml`].join('/'),
+        ];
+        const result = await this.fileStorage.getFileContent({ paths });
+        if (!result.found) {
+            return {
+                found: false,
+            };
+        }
+        const { data, error } = await parseYaml(result.content);
+        if (error) {
+            return {
+                error,
+                found: true,
+                hasError: true,
+            };
+        }
+        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 workspaces$ = await this.fileStorage.listFileNames({ directory: 'state/workspaces' });
+        if (workspaces$.success) {
+            return workspaces$.files
+                .filter((workspace) => workspace.endsWith('.yaml') || workspace.endsWith('.yml'))
+                .map((workspace) => workspace.replace(/\.yaml|\.yml$/, ''))
+                .sort();
+        }
+        throw new Error(`Could not list workspaces: ${workspaces$.error}`);
+    }
+    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 paths = [
+            ['state', 'projects', workspace ?? config.workspace, `${config.project}.yaml`].join('/'),
+            ['state', 'projects', workspace ?? config.workspace, `${config.project}.yml`].join('/'),
+        ];
+        const object = {
+            ...config,
+            workspace: workspace ?? config.workspace,
+        };
+        await this.fileStorage.saveFileContent({ content: stringify(object), paths });
+    }
+    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 saveWorkspace(data, name) {
+        const paths = [['state', 'workspaces', `${name}.yaml`].join('/'), ['state', 'workspaces', `${name}.yml`].join('/')];
+        await this.fileStorage.saveFileContent({ content: stringify(data), paths });
+    }
+}

package/dist/backend/index.d.ts

@@ -1,4 +1,6 @@
 import { Backend } from './common.js';
-import { LocalBackend } from './local.js';
-export declare const localBackend: LocalBackend;
 export declare function getBackend(): Promise<Backend>;
+export declare enum BackendType {
+    Local = "local",
+    S3 = "s3"
+}

package/dist/backend/index.js

@@ -1,5 +1,34 @@
-import { LocalBackend } from './local.js';
-export const localBackend = new LocalBackend();
+import { getAwsConfig } from '../infrastructure/aws-config.js';
+import { getCurrentBackendType } from './config.js';
+import { LocalFileBackend } from './local.js';
+import { S3FileBackend } from './s3.js';
+let backend;
 export async function getBackend() {
-    return localBackend;
+    if (backend) {
+        return backend;
+    }
+    const backendType = await getCurrentBackendType();
+    switch (backendType) {
+        case BackendType.Local: {
+            backend = new LocalFileBackend();
+            break;
+        }
+        case BackendType.S3: {
+            const config = await getAwsConfig();
+            if (!config.backendBucket) {
+                throw new Error('Backend bucket not found. Please run `hereya bootstrap aws` first.');
+            }
+            backend = new S3FileBackend(config.backendBucket);
+            break;
+        }
+        default: {
+            throw new Error(`Unsupported backend type: ${backendType}`);
+        }
+    }
+    return backend;
 }
+export var BackendType;
+(function (BackendType) {
+    BackendType["Local"] = "local";
+    BackendType["S3"] = "s3";
+})(BackendType || (BackendType = {}));

package/dist/backend/local.d.ts

@@ -1,20 +1,4 @@
-import { Config } from '../lib/config/common.js';
-import { AddPackageToWorkspaceInput, AddPackageToWorkspaceOutput, Backend, CreateWorkspaceInput, CreateWorkspaceOutput, DeleteWorkspaceInput, DeleteWorkspaceOutput, GetProvisioningIdInput, GetProvisioningIdOutput, GetStateInput, GetStateOutput, GetWorkspaceEnvInput, GetWorkspaceEnvOutput, GetWorkspaceOutput, InitProjectInput, InitProjectOutput, RemovePackageFromWorkspaceInput, RemovePackageFromWorkspaceOutput, SetEnvVarInput, SetEnvVarOutput, UnsetEnvVarInput, UnsetEnvVarOutput } from './common.js';
-export declare class LocalBackend implements Backend {
-    addPackageToWorkspace(input: AddPackageToWorkspaceInput): Promise<AddPackageToWorkspaceOutput>;
-    createWorkspace(input: CreateWorkspaceInput): Promise<CreateWorkspaceOutput>;
-    deleteWorkspace(input: DeleteWorkspaceInput): Promise<DeleteWorkspaceOutput>;
-    getProvisioningId(input: GetProvisioningIdInput): Promise<GetProvisioningIdOutput>;
-    getState(input: GetStateInput): Promise<GetStateOutput>;
-    getWorkspace(workspace: string): Promise<GetWorkspaceOutput>;
-    getWorkspaceEnv(input: GetWorkspaceEnvInput): Promise<GetWorkspaceEnvOutput>;
-    init(options: InitProjectInput): Promise<InitProjectOutput>;
-    listWorkspaces(): Promise<string[]>;
-    removePackageFromWorkspace(input: RemovePackageFromWorkspaceInput): Promise<RemovePackageFromWorkspaceOutput>;
-    saveState(config: Config, workspace?: string): Promise<void>;
-    setEnvVar(input: SetEnvVarInput): Promise<SetEnvVarOutput>;
-    unsetEnvVar(input: UnsetEnvVarInput): Promise<UnsetEnvVarOutput>;
-    private getProjectStatePath;
-    private getWorkspacePath;
-    private saveWorkspace;
+import { FileBackend } from './file.js';
+export declare class LocalFileBackend extends FileBackend {
+    constructor(basePath?: string);
 }