hereya-cli 0.17.2 → 0.19.0

package/dist/executor/interface.d.ts

@@ -0,0 +1,41 @@
+import { IPackageMetadata } from '../lib/package/index.js';
+export type ExecutorProvisionInput = {
+    isDeploying?: boolean;
+    package: string;
+    parameters?: {
+        [key: string]: string;
+    };
+    project?: string;
+    projectEnv?: {
+        [key: string]: string;
+    };
+    projectRootDir?: string;
+    skipDeploy?: boolean;
+    workspace?: string;
+};
+export type ExecutorProvisionOutput = {
+    env: {
+        [key: string]: string;
+    };
+    metadata: IPackageMetadata;
+    success: true;
+} | {
+    reason: string;
+    success: false;
+};
+export type ExecutorDestroyInput = ExecutorProvisionInput;
+export type ExecutorDestroyOutput = ExecutorProvisionOutput;
+export type ExecutorResolveEnvValuesInput = {
+    env: {
+        [key: string]: string;
+    };
+    markSecret?: boolean;
+};
+export type ExecutorResolveEnvValuesOutput = {
+    [key: string]: string;
+};
+export interface Executor {
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+}

package/dist/executor/interface.js

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

package/dist/executor/local.d.ts

@@ -0,0 +1,7 @@
+import { Executor, ExecutorDestroyInput, ExecutorDestroyOutput, ExecutorProvisionInput, ExecutorProvisionOutput, ExecutorResolveEnvValuesInput, ExecutorResolveEnvValuesOutput } from './interface.js';
+export declare class LocalExecutor implements Executor {
+    destroy(input: ExecutorDestroyInput): Promise<ExecutorDestroyOutput>;
+    provision(input: ExecutorProvisionInput): Promise<ExecutorProvisionOutput>;
+    resolveEnvValues(input: ExecutorResolveEnvValuesInput): Promise<ExecutorResolveEnvValuesOutput>;
+    private getWorkspaceEnv;
+}

package/dist/executor/local.js

@@ -0,0 +1,56 @@
+import { getBackend } from '../backend/index.js';
+import { destroyPackage, getInfrastructure, provisionPackage } from '../infrastructure/index.js';
+export class LocalExecutor {
+    async destroy(input) {
+        const getWorkspaceEnvOutput = await this.getWorkspaceEnv({
+            project: input.project,
+            workspace: input.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            return { reason: getWorkspaceEnvOutput.reason, success: false };
+        }
+        return destroyPackage({
+            ...input,
+            env: getWorkspaceEnvOutput.env,
+        });
+    }
+    async provision(input) {
+        const getWorkspaceEnvOutput = await this.getWorkspaceEnv({
+            project: input.project,
+            workspace: input.workspace,
+        });
+        if (!getWorkspaceEnvOutput.success) {
+            return { reason: getWorkspaceEnvOutput.reason, success: false };
+        }
+        return provisionPackage({
+            ...input,
+            env: getWorkspaceEnvOutput.env,
+        });
+    }
+    async resolveEnvValues(input) {
+        return Object.fromEntries(await Promise.all(Object.entries(input.env).map(async ([key, value]) => {
+            const infraType = value.split(':')[0];
+            const infra$ = getInfrastructure({ type: infraType });
+            if (!infra$.supported) {
+                throw new Error(infra$.reason);
+            }
+            const { infrastructure } = infra$;
+            const valueWithoutInfra = value.split(':').slice(1).join(':');
+            const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
+                value: valueWithoutInfra,
+            });
+            const finalValue = input.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
+            return [key, finalValue];
+        })));
+    }
+    async getWorkspaceEnv({ project, workspace, }) {
+        if (!workspace || !project) {
+            return { env: {}, success: true };
+        }
+        const backend = await getBackend();
+        return backend.getWorkspaceEnv({
+            project,
+            workspace,
+        });
+    }
+}

package/dist/iac/index.js

@@ -5,21 +5,21 @@ export const terraform = new Terraform();
 export const cdk = new Cdk();
 export function getIac({ type }) {
     switch (type) {
-        case IacType.terraform: {
+        case IacType.cdk: {
+            return { iac: cdk, supported: true };
+        }
+        case IacType.opentf: {
             return { iac: terraform, supported: true };
         }
         case IacType.opentofu: {
             return { iac: terraform, supported: true };
         }
-        case IacType.opentf: {
+        case IacType.terraform: {
             return { iac: terraform, supported: true };
         }
         case IacType.tofu: {
             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.js

@@ -119,8 +119,8 @@ export class Terraform {
             ['freebsd_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_arm.zip'],
             ['freebsd_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_386.zip'],
             ['freebsd_x64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_freebsd_amd64.zip'],
-            ['linux_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm.zip'],
             ['linux_arm64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm64.zip'],
+            ['linux_arm', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_arm.zip'],
             ['linux_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_386.zip'],
             ['linux_x64', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_linux_amd64.zip'],
             ['openbsd_ia32', 'https://github.com/opentofu/opentofu/releases/download/v1.9.0/tofu_1.9.0_openbsd_386.zip'],

package/dist/infrastructure/common.d.ts

@@ -44,12 +44,12 @@ export type ProvisionOutput = {
 };
 export type DestroyInput = ProvisionInput;
 export type DestroyOutput = ProvisionOutput;
-export type DeployInput = {
+export type DeployInput = ProvisionInput & {
     projectEnv: {
         [key: string]: string;
     };
     projectRootDir: string;
-} & ProvisionInput;
+};
 export type DeployOutput = ProvisionOutput;
 export type UndeployInput = DeployInput;
 export type UndeployOutput = DeployOutput;

package/dist/infrastructure/index.d.ts

@@ -41,10 +41,10 @@ export type GetInfrastructureInput = {
     type: InfrastructureType;
 };
 export type GetInfrastructureOutput = {
-    reason: string;
-    supported: false;
-} | {
     infrastructure: Infrastructure;
     supported: true;
+} | {
+    reason: string;
+    supported: false;
 };
 export type PackageMetadata = z.infer<typeof PackageMetadata>;

package/dist/infrastructure/index.js

@@ -7,15 +7,15 @@ export const localInfrastructure = new LocalInfrastructure();
 export const awsInfrastructure = new AwsInfrastructure();
 export function getInfrastructure(input) {
     switch (input.type) {
-        case InfrastructureType.local: {
+        case InfrastructureType.aws: {
             return {
-                infrastructure: localInfrastructure,
+                infrastructure: awsInfrastructure,
                 supported: true,
             };
         }
-        case InfrastructureType.aws: {
+        case InfrastructureType.local: {
             return {
-                infrastructure: awsInfrastructure,
+                infrastructure: localInfrastructure,
                 supported: true,
             };
         }
@@ -28,7 +28,7 @@ export function getInfrastructure(input) {
     }
 }
 export async function destroyPackage(input) {
-    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package });
+    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package, projectRootDir: input.projectRootDir });
     if (!resolvePackageOutput.found) {
         return { reason: resolvePackageOutput.reason, success: false };
     }
@@ -91,7 +91,7 @@ export async function destroyPackage(input) {
     return { env: destroyOutput.env, metadata, success: true };
 }
 export async function provisionPackage(input) {
-    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package });
+    const resolvePackageOutput = await resolvePackage({ isDeploying: input.isDeploying, package: input.package, projectRootDir: input.projectRootDir });
     if (!resolvePackageOutput.found) {
         return { reason: resolvePackageOutput.reason, success: false };
     }

package/dist/infrastructure/local.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
-import * as path from 'node:path';
+import path from 'node:path';
 import { getIac } from '../iac/index.js';
 import { downloadPackage } from '../lib/package/index.js';
 export class LocalInfrastructure {

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

@@ -26,4 +26,8 @@ export type GetProjectEnvOutput = {
     env: {
         [key: string]: string;
     };
+    success: true;
+} | {
+    reason: string;
+    success: false;
 };

package/dist/lib/env/index.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { resolveEnvValues } from '../env-utils.js';
+import { getExecutor } from '../../executor/index.js';
 import { getAnyPath } from '../filesystem.js';
 import { load, save } from '../yaml-utils.js';
 export class EnvManager {
@@ -14,8 +14,16 @@ export class EnvManager {
         const envPath = await this.getEnvPath(input);
         const { data: env, found } = await load(envPath);
         let resolvedEnv = {};
+        const executor$ = getExecutor();
+        if (!executor$.success) {
+            return {
+                reason: executor$.reason,
+                success: false,
+            };
+        }
+        const { executor } = executor$;
         if (found) {
-            resolvedEnv = await resolveEnvValues(env, { markSecret: input.markSecret });
+            resolvedEnv = await executor.resolveEnvValues({ env, markSecret: input.markSecret });
         }
         const userEnvs = await this.getUserEnvPaths(input).then((paths) => Promise.all(paths.map((path) => load(path))));
         let userMergedEnv = {};
@@ -23,7 +31,7 @@ export class EnvManager {
             userMergedEnv = { ...userMergedEnv, ...data };
         }
         const finalEnv = { ...resolvedEnv, ...userMergedEnv };
-        return { env: finalEnv };
+        return { env: finalEnv, success: true };
     }
     async removeProjectEnv(input) {
         const envPath = await this.getEnvPath(input);

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

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

package/dist/lib/env-utils.js

@@ -1,23 +1,5 @@
-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, options = {}) {
-    return Object.fromEntries(await Promise.all(Object.entries(env)
-        .map(async ([key, value]) => {
-        const infraType = value.split(':')[0];
-        const infra$ = getInfrastructure({ type: infraType });
-        if (!infra$.supported) {
-            throw new Error(infra$.reason);
-        }
-        const { infrastructure } = infra$;
-        const valueWithoutInfra = value.split(':').slice(1).join(':');
-        const { isSecret, value: resolvedValue } = await infrastructure.resolveEnv({
-            value: valueWithoutInfra
-        });
-        const finalValue = options.markSecret && isSecret ? `secret://${resolvedValue}` : resolvedValue;
-        return [key, finalValue];
-    })));
-}

package/dist/lib/log.js

@@ -1,4 +1,4 @@
-import { ListrLogLevels, ListrLogger } from 'listr2';
+import { ListrLogger, ListrLogLevels } from 'listr2';
 const myLogger = new ListrLogger({ useIcons: false });
 const logger = {
     done(message) {

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

@@ -5,6 +5,7 @@ export interface PackageManager {
 export type GetRepoContentInput = {
     owner: string;
     path: string;
+    projectRootDir?: string;
     repo: string;
 };
 export type GetRepoContentOutput = {

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

@@ -1,5 +1,7 @@
 import type { GetRepoContentInput, GetRepoContentOutput, PackageManager } from './common.js';
 export declare class GitHubPackageManager implements PackageManager {
+    private readonly registryUrl;
+    constructor(registryUrl?: string);
     downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
     getRepoContent({ owner, path: filePath, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
 }

package/dist/lib/package/github.js

@@ -11,6 +11,10 @@ import { simpleGit } from 'simple-git';
 import { BackOffPolicy, Retryable } from 'typescript-retry-decorator';
 import { isNotEmpty } from '../filesystem.js';
 export class GitHubPackageManager {
+    registryUrl;
+    constructor(registryUrl = process.env.HEREYA_REGISTRY_URL || 'https://github.com') {
+        this.registryUrl = registryUrl;
+    }
     // eslint-disable-next-line new-cap
     async downloadPackage(pkgUrl, destPath) {
         if (await isNotEmpty(destPath)) {
@@ -24,7 +28,7 @@ export class GitHubPackageManager {
         return destPath;
     }
     async getRepoContent({ owner, path: filePath, repo }) {
-        const pkgUrl = `https://github.com/${owner}/${repo}`;
+        const pkgUrl = `${this.registryUrl}/${owner}/${repo}`;
         const tmpFolder = path.join(os.tmpdir(), 'hereya', 'github', owner, repo);
         try {
             const destPath = await this.downloadPackage(pkgUrl, tmpFolder);

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

@@ -2,14 +2,17 @@ import { z } from 'zod';
 import { IacType } from '../../iac/common.js';
 import { InfrastructureType } from '../../infrastructure/common.js';
 import { PackageManager } from './common.js';
+import { LocalPackageManager } from './local.js';
 export declare const packageManager: PackageManager;
-export declare function getPackageManager(): PackageManager;
+export declare const localPackageManager: LocalPackageManager;
+export declare function getPackageManager(protocol: string): PackageManager;
 export declare function resolvePackage(input: ResolvePackageInput): Promise<ResolvePackageOutput>;
 export declare function getPackageCanonicalName(packageName: string): string;
 export declare function downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
 export type ResolvePackageInput = {
     isDeploying?: boolean;
     package: string;
+    projectRootDir?: string;
 };
 export type ResolvePackageOutput = {
     canonicalName: string;

package/dist/lib/package/index.js

@@ -3,20 +3,34 @@ import { z } from 'zod';
 import { IacType } from '../../iac/common.js';
 import { InfrastructureType } from '../../infrastructure/common.js';
 import { GitHubPackageManager } from './github.js';
+import { LocalPackageManager } from './local.js';
 export const packageManager = new GitHubPackageManager();
-export function getPackageManager() {
+export const localPackageManager = new LocalPackageManager();
+export function getPackageManager(protocol) {
+    if (protocol === 'local') {
+        return localPackageManager;
+    }
     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 isLocal = input.package.startsWith('local://');
+    let [owner, repo] = ['', ''];
+    if (isLocal) {
+        ;
+        [owner, repo] = input.package.split('://');
+    }
+    else {
+        const pkgParts = input.package.split('/');
+        if (pkgParts.length !== 2) {
+            return { found: false, reason: 'Invalid package format. Use owner/repository' };
+        }
+        ;
+        [owner, repo] = pkgParts;
     }
-    const [owner, repo] = pkgParts;
-    const packageManager = getPackageManager();
+    const packageManager = getPackageManager(isLocal ? 'local' : '');
     const metadataContentCandidates = (await Promise.all([
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', repo }),
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', projectRootDir: input.projectRootDir, repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', projectRootDir: input.projectRootDir, repo }),
     ])).filter((content$) => content$.found);
     if (metadataContentCandidates.length === 0) {
         return { found: false, reason: `No hereya metadata file found in ${input.package}` };
@@ -28,7 +42,7 @@ export async function resolvePackage(input) {
             return { found: false, reason: 'Package has dependencies but is not a deploy package' };
         }
         if (input.isDeploying && metadata.onDeploy) {
-            return resolvePackage({ package: metadata.onDeploy.pkg });
+            return resolvePackage({ package: metadata.onDeploy.pkg, projectRootDir: input.projectRootDir });
         }
         return {
             canonicalName: getPackageCanonicalName(input.package),
@@ -43,10 +57,14 @@ export async function resolvePackage(input) {
     }
 }
 export function getPackageCanonicalName(packageName) {
+    const isLocal = packageName.startsWith('local://');
+    if (isLocal) {
+        return packageName.replace('local://', 'local--').replace('/', '-');
+    }
     return packageName.replace('/', '-');
 }
 export async function downloadPackage(pkgUrl, destPath) {
-    const packageManager = getPackageManager();
+    const packageManager = getPackageManager(pkgUrl.startsWith('local://') ? 'local' : '');
     return packageManager.downloadPackage(pkgUrl, destPath);
 }
 export const PackageMetadata = z.object({

package/dist/lib/package/local.d.ts

@@ -0,0 +1,5 @@
+import { GetRepoContentInput, GetRepoContentOutput, PackageManager } from './common.js';
+export declare class LocalPackageManager implements PackageManager {
+    downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
+    getRepoContent({ path: filePath, projectRootDir, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
+}

package/dist/lib/package/local.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class LocalPackageManager {
+    async downloadPackage(pkgUrl, destPath) {
+        const [, source] = pkgUrl.split('://');
+        await copyRecursive(source, destPath);
+        return destPath;
+    }
+    async getRepoContent({ path: filePath, projectRootDir, repo }) {
+        try {
+            const pkgRootDir = path.join(projectRootDir ?? process.cwd(), repo);
+            const resolvedPath = path.join(pkgRootDir, filePath);
+            if (await fs.stat(resolvedPath)) {
+                const content = await fs.readFile(resolvedPath, 'utf8');
+                return {
+                    content,
+                    found: true,
+                    pkgUrl: `local://${pkgRootDir}`,
+                };
+            }
+            return {
+                found: false,
+                reason: `File ${filePath} not found in ${repo}`,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                reason: error.message,
+            };
+        }
+    }
+}
+async function copyRecursive(src, dest) {
+    // Ensure the destination directory exists.
+    await fs.mkdir(dest, { recursive: true });
+    // Read the contents of the source directory.
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    // Loop through each entry in the directory.
+    await Promise.all(entries.map(async (entry) => {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        return entry.isDirectory() ? copyRecursive(srcPath, destPath) : fs.copyFile(srcPath, destPath);
+    }));
+}

package/dist/lib/shell.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { StdioOptions, spawnSync } from 'node:child_process';
+import { spawnSync, StdioOptions } from 'node:child_process';
 export declare function setDebug(value: boolean): void;
 export declare function isDebug(): boolean;
 export type RunShellOptions = {

package/dist/lib/yaml-utils.js

@@ -1,5 +1,5 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import * as path from 'node:path';
+import path from 'node:path';
 import { parse, stringify } from 'yaml';
 export async function save(content, file) {
     try {

package/oclif.manifest.json

@@ -54,6 +54,45 @@
         "index.js"
       ]
     },
+    "bootstrap": {
+      "aliases": [],
+      "args": {
+        "infrastructureType": {
+          "description": "infrastructure to bootstrap. Options are local, aws",
+          "name": "infrastructureType",
+          "required": true
+        }
+      },
+      "description": "Install necessary resources for hereya operations in an infrastructure.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> aws",
+        "<%= config.bin %> <%= command.id %> local"
+      ],
+      "flags": {
+        "force": {
+          "char": "f",
+          "description": "redeploy hereya resources if already deployed",
+          "name": "force",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "bootstrap",
+      "pluginAlias": "hereya-cli",
+      "pluginName": "hereya-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "bootstrap",
+        "index.js"
+      ]
+    },
     "deploy": {
       "aliases": [],
       "args": {},
@@ -102,45 +141,6 @@
         "index.js"
       ]
     },
-    "bootstrap": {
-      "aliases": [],
-      "args": {
-        "infrastructureType": {
-          "description": "infrastructure to bootstrap. Options are local, aws",
-          "name": "infrastructureType",
-          "required": true
-        }
-      },
-      "description": "Install necessary resources for hereya operations in an infrastructure.",
-      "examples": [
-        "<%= config.bin %> <%= command.id %> aws",
-        "<%= config.bin %> <%= command.id %> local"
-      ],
-      "flags": {
-        "force": {
-          "char": "f",
-          "description": "redeploy hereya resources if already deployed",
-          "name": "force",
-          "allowNo": false,
-          "type": "boolean"
-        }
-      },
-      "hasDynamicHelp": false,
-      "hiddenAliases": [],
-      "id": "bootstrap",
-      "pluginAlias": "hereya-cli",
-      "pluginName": "hereya-cli",
-      "pluginType": "core",
-      "strict": true,
-      "enableJsonFlag": false,
-      "isESM": true,
-      "relativePath": [
-        "dist",
-        "commands",
-        "bootstrap",
-        "index.js"
-      ]
-    },
     "down": {
       "aliases": [],
       "args": {},
@@ -954,5 +954,5 @@
       ]
     }
   },
-  "version": "0.17.2"
+  "version": "0.19.0"
 }