hereya-cli 0.2.1

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

@@ -0,0 +1,27 @@
+import { InfrastructureType } from '../../infrastructure/common.js';
+export declare class EnvManager {
+    addProjectEnv(input: AddEnvInput): Promise<void>;
+    getProjectEnv(input: GetProjectEnvInput): Promise<GetProjectEnvOutput>;
+    removeProjectEnv(input: RemoveEnvInput): Promise<void>;
+    private getEnvPath;
+}
+export declare const envManager: EnvManager;
+export declare function getEnvManager(): EnvManager;
+export type AddEnvInput = {
+    env: {
+        [key: string]: string;
+    };
+    infra: InfrastructureType;
+    projectRootDir?: string;
+    workspace: string;
+};
+export type RemoveEnvInput = AddEnvInput;
+export type GetProjectEnvInput = {
+    projectRootDir?: string;
+    workspace: string;
+};
+export type GetProjectEnvOutput = {
+    env: {
+        [key: string]: string;
+    };
+};

package/dist/lib/env/index.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import { resolveEnvValues } from '../env-utils.js';
+import { getAnyPath } from '../filesystem.js';
+import { load, save } from '../yaml-utils.js';
+export class EnvManager {
+    async addProjectEnv(input) {
+        const envPath = await this.getEnvPath(input);
+        const { data: existingEnv } = await load(envPath);
+        const newEnv = Object.fromEntries(Object.entries(input.env)
+            .map(([key, value]) => [key, `${input.infra}:${value}`]));
+        const finalEnv = { ...existingEnv, ...newEnv };
+        await save(finalEnv, envPath);
+    }
+    async getProjectEnv(input) {
+        const envPath = await this.getEnvPath(input);
+        const { data: env, found } = await load(envPath);
+        if (!found) {
+            return { env: {} };
+        }
+        const resolvedEnv = await resolveEnvValues(env);
+        return { env: resolvedEnv };
+    }
+    async removeProjectEnv(input) {
+        const envPath = await this.getEnvPath(input);
+        const { data: existingEnv, found } = await load(envPath);
+        if (!found) {
+            return;
+        }
+        const envKeysToRemove = Object.keys(input.env);
+        const finalEnv = Object.fromEntries(Object
+            .entries(existingEnv)
+            .filter(([key]) => !envKeysToRemove.includes(key)));
+        await save(finalEnv, envPath);
+    }
+    async getEnvPath(input) {
+        return getAnyPath(path.join(input.projectRootDir ?? process.cwd(), '.hereya', `env.${input.workspace}.yaml`), path.join(input.projectRootDir ?? process.cwd(), '.hereya', `env.${input.workspace}.yml`));
+    }
+}
+export const envManager = new EnvManager();
+export function getEnvManager() {
+    return envManager;
+}

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

@@ -0,0 +1,8 @@
+export declare function logEnv(env: {
+    [key: string]: string;
+}, logFn?: (_: string) => void): void;
+export declare function resolveEnvValues(env: {
+    [key: string]: string;
+}): Promise<{
+    [key: string]: string;
+}>;

package/dist/lib/env-utils.js

@@ -0,0 +1,20 @@
+import { getInfrastructure } from '../infrastructure/index.js';
+export function logEnv(env, logFn = console.log) {
+    for (const [key, value] of Object.entries(env)) {
+        logFn(`${key}=${value}`);
+    }
+}
+export async function resolveEnvValues(env) {
+    return Object.fromEntries(await Promise.all(Object.entries(env)
+        .map(async ([key, value]) => {
+        const infraType = value.split(':')[0];
+        const infra$ = await getInfrastructure({ type: infraType });
+        if (!infra$.supported) {
+            throw new Error(infra$.reason);
+        }
+        const { infrastructure } = infra$;
+        const valueWithoutInfra = value.split(':').slice(1).join(':');
+        const { value: resolvedValue } = await infrastructure.resolveEnv({ value: valueWithoutInfra });
+        return [key, resolvedValue];
+    })));
+}

package/dist/lib/filesystem.d.ts

@@ -0,0 +1 @@
+export declare function getAnyPath(...candidates: string[]): Promise<string>;

package/dist/lib/filesystem.js

@@ -0,0 +1,15 @@
+import { access, constants } from 'node:fs/promises';
+export async function getAnyPath(...candidates) {
+    const checkAccess = async (index) => {
+        if (index >= candidates.length)
+            return candidates[0];
+        try {
+            await access(candidates[index], constants.W_OK);
+            return candidates[index];
+        }
+        catch {
+            return checkAccess(index + 1);
+        }
+    };
+    return checkAccess(0);
+}

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

@@ -0,0 +1,4 @@
+export declare function mapObject(obj: object, fn: (key: string, value: any) => [string, any]): object;
+export declare function arrayOfStringToObject(arr: string[], keyValueSeparator?: string): {
+    [k: string]: string;
+};

package/dist/lib/object-utils.js

@@ -0,0 +1,9 @@
+export function mapObject(obj, fn) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => fn(key, value)));
+}
+export function arrayOfStringToObject(arr, keyValueSeparator = '=') {
+    return Object.fromEntries(arr.map((item) => {
+        const [key, value] = item.split(keyValueSeparator);
+        return [key, value];
+    }));
+}

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

@@ -0,0 +1,15 @@
+export interface PackageManager {
+    getRepoContent: (input: GetRepoContentInput) => Promise<GetRepoContentOutput>;
+}
+export type GetRepoContentInput = {
+    owner: string;
+    path: string;
+    repo: string;
+};
+export type GetRepoContentOutput = {
+    content: string;
+    found: true;
+} | {
+    found: false;
+    reason: string;
+};

package/dist/lib/package/common.js

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

package/dist/lib/package/github.d.ts

@@ -0,0 +1,4 @@
+import type { GetRepoContentInput, GetRepoContentOutput, PackageManager } from './common.js';
+export declare class GitHubPackageManager implements PackageManager {
+    getRepoContent({ owner, path, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
+}

package/dist/lib/package/github.js

@@ -0,0 +1,32 @@
+import { Octokit } from '@octokit/rest';
+export class GitHubPackageManager {
+    async getRepoContent({ owner, path, repo }) {
+        const octokit = new Octokit();
+        try {
+            const response = await octokit.rest.repos.getContent({
+                headers: {
+                    'Accept': 'application/vnd.github.raw+json'
+                },
+                owner,
+                path,
+                repo
+            });
+            if (response.status !== 200) {
+                return {
+                    found: false,
+                    reason: `Failed to fetch content: ${response.status}`
+                };
+            }
+            return {
+                content: response.data,
+                found: true
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                reason: error.message
+            };
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { IacType } from '../../iac/common.js';
+import { InfrastructureType } from '../../infrastructure/common.js';
+import { PackageManager } from './common.js';
+export declare const packageManager: PackageManager;
+export declare function getPackageManager(): PackageManager;
+export declare function resolvePackage(input: ResolvePackageInput): Promise<ResolvePackageOutput>;
+export declare function getPackageCanonicalName(packageName: string): string;
+export type ResolvePackageInput = {
+    package: string;
+};
+export type ResolvePackageOutput = {
+    canonicalName: string;
+    found: true;
+    metadata: z.infer<typeof PackageMetadata>;
+    packageUri: string;
+} | {
+    found: false;
+    reason: string;
+};
+export declare const PackageMetadata: z.ZodObject<{
+    iac: z.ZodNativeEnum<typeof IacType>;
+    infra: z.ZodNativeEnum<typeof InfrastructureType>;
+}, "strip", z.ZodTypeAny, {
+    iac: IacType;
+    infra: InfrastructureType;
+}, {
+    iac: IacType;
+    infra: InfrastructureType;
+}>;

package/dist/lib/package/index.js

@@ -0,0 +1,45 @@
+import * as yaml from 'yaml';
+import { z } from 'zod';
+import { IacType } from '../../iac/common.js';
+import { InfrastructureType } from '../../infrastructure/common.js';
+import { GitHubPackageManager } from './github.js';
+export const packageManager = new GitHubPackageManager();
+export function getPackageManager() {
+    return packageManager;
+}
+export async function resolvePackage(input) {
+    const pkgParts = input.package.split('/');
+    if (pkgParts.length !== 2) {
+        return { found: false, reason: 'Invalid package format. Use owner/repository' };
+    }
+    const [owner, repo] = pkgParts;
+    const pkgUrl = `https://github.com/${input.package}`;
+    const packageManager = getPackageManager();
+    const metadataContentCandidates = (await Promise.all([
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', repo }),
+    ])).filter(content$ => content$.found);
+    if (metadataContentCandidates.length === 0) {
+        return { found: false, reason: `No hereya metadata file found in ${pkgUrl}` };
+    }
+    const metadataContent$ = metadataContentCandidates[0];
+    try {
+        const metadata = PackageMetadata.parse(yaml.parse(metadataContent$.content));
+        return {
+            canonicalName: getPackageCanonicalName(input.package),
+            found: true,
+            metadata,
+            packageUri: pkgUrl
+        };
+    }
+    catch (error) {
+        return { found: false, reason: error.message };
+    }
+}
+export function getPackageCanonicalName(packageName) {
+    return packageName.replace('/', '-');
+}
+export const PackageMetadata = z.object({
+    iac: z.nativeEnum(IacType),
+    infra: z.nativeEnum(InfrastructureType),
+});

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

@@ -0,0 +1,34 @@
+export declare class ParameterManager {
+    getPackageParameters(input: GetPackageParametersInput): Promise<GetPackageParametersOutput>;
+    savePackageParameters(input: SavePackageParametersInput): Promise<SavePackageParametersOutput>;
+}
+export declare const parameterManager: ParameterManager;
+export declare function getParameterManager(): ParameterManager;
+export type GetPackageParametersInput = {
+    package: string;
+    projectRootDir?: string;
+    userSpecifiedParameters?: {
+        [key: string]: string;
+    };
+    workspace: string;
+};
+export type GetPackageParametersOutput = {
+    parameters: {
+        [key: string]: string;
+    };
+};
+export type SavePackageParametersInput = {
+    package: string;
+    parameters: {
+        [key: string]: string;
+    };
+    projectRootDir?: string;
+    workspace: string;
+};
+export type SavePackageParametersOutput = {
+    filePath: null;
+    saved: false;
+} | {
+    filePath: string;
+    saved: true;
+};

package/dist/lib/parameter/index.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { getAnyPath } from '../filesystem.js';
+import { getPackageCanonicalName } from '../package/index.js';
+import { load, save } from '../yaml-utils.js';
+export class ParameterManager {
+    async getPackageParameters(input) {
+        const pkgName = getPackageCanonicalName(input.package);
+        const fromFiles = await Promise.all([
+            [`${pkgName}.yaml`, `${pkgName}.yml`],
+            [`${pkgName}.${input.workspace}.yaml`, `${pkgName}.${input.workspace}.yml`],
+        ].map(async ([filename, altFilename]) => {
+            const filePath = await getAnyPath(path.join(input.projectRootDir ?? process.cwd(), 'hereyavars', filename), path.join(input.projectRootDir ?? process.cwd(), 'hereyavars', altFilename));
+            const { data: parameters } = await load(filePath);
+            return parameters;
+        }));
+        const fromUser = input.userSpecifiedParameters;
+        const parameters = Object.assign({}, ...fromFiles, fromUser ?? {});
+        return { parameters };
+    }
+    async savePackageParameters(input) {
+        const pkgName = getPackageCanonicalName(input.package);
+        const paramFilesExist = await Promise.all([
+            [`${pkgName}.yaml`, `${pkgName}.yml`],
+            [`${pkgName}.${input.workspace}.yaml`, `${pkgName}.${input.workspace}.yml`],
+        ].map(async ([filename, altFilename]) => {
+            const filePath = await getAnyPath(path.join(input.projectRootDir ?? process.cwd(), 'hereyavars', filename), path.join(input.projectRootDir ?? process.cwd(), 'hereyavars', altFilename));
+            const { found } = await load(filePath);
+            return found;
+        }));
+        if (paramFilesExist.some(Boolean)) {
+            return {
+                filePath: null,
+                saved: false,
+            };
+        }
+        const filePath = path.join(input.projectRootDir ?? process.cwd(), 'hereyavars', `${pkgName}.yaml`);
+        await save(input.parameters, filePath);
+        return {
+            filePath,
+            saved: true,
+        };
+    }
+}
+export const parameterManager = new ParameterManager();
+export function getParameterManager() {
+    return parameterManager;
+}

package/dist/lib/shell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { StdioOptions, spawnSync } from 'node:child_process';
+export type RunShellOptions = {
+    directory?: string;
+    env?: NodeJS.ProcessEnv;
+    stdio?: StdioOptions;
+};
+export declare function runShell(cmd: string, args: string[], options?: RunShellOptions): ReturnType<typeof spawnSync>;

package/dist/lib/shell.js

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+export function runShell(cmd, args, options = {}) {
+    // Run the command
+    const result = spawnSync(cmd, args, {
+        cwd: options.directory ?? process.cwd(),
+        encoding: 'utf8',
+        env: { ...process.env, ...options.env },
+        shell: true,
+        stdio: options.stdio ?? 'inherit',
+    });
+    // Throw an error if the command failed
+    if (result.status !== 0) {
+        throw new Error(`Command "${cmd} ${args.join(' ')}" failed with exit code "${result.status}"`);
+    }
+    return result;
+}

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

@@ -0,0 +1,5 @@
+export declare function save<T extends object>(content: T, file: string): Promise<void>;
+export declare function load<T extends object>(file: string): Promise<{
+    data: T;
+    found: boolean;
+}>;

package/dist/lib/yaml-utils.js

@@ -0,0 +1,27 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import { parse, stringify } from 'yaml';
+export async function save(content, file) {
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, stringify(content), { encoding: 'utf8' });
+    }
+    catch (error) {
+        throw new Error(`could not save data to file ${file} ${error}`);
+    }
+}
+export async function load(file) {
+    let data = {};
+    let found = false;
+    try {
+        const content = await readFile(file, { encoding: 'utf8' });
+        data = parse(content);
+        found = true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw new Error(`could not load file ${file}: ${error}`);
+        }
+    }
+    return { data: data || {}, found };
+}