@salte-common/terraflow 0.1.0-alpha.1

package/dist/core/environment.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Environment setup
+ * Sets up cloud, VCS, and Terraform environment
+ */
+import type { TerraflowConfig } from '../types/config';
+import type { ExecutionContext } from '../types/context';
+/**
+ * Environment setup utilities
+ */
+export declare class EnvironmentSetup {
+    /**
+     * Load .env file from working directory
+     * Does NOT auto-convert to TF_VAR_* - only loads general environment variables
+     * @param workingDir - Working directory path
+     * @returns Record of environment variables from .env file
+     */
+    static loadEnvFile(workingDir: string): Record<string, string>;
+    /**
+     * Setup cloud provider environment (AWS, Azure, GCP)
+     * - Syncs AWS_REGION and AWS_DEFAULT_REGION
+     * - Fetches account/subscription/project IDs
+     * @returns Updated cloud info
+     */
+    static setupCloud(): Promise<ExecutionContext['cloud']>;
+    /**
+     * Setup VCS environment (git variables)
+     * Sets GitHub Actions and GitLab CI compatible variables
+     * @param context - Execution context
+     * @returns Updated context with VCS environment variables
+     */
+    static setupVcs(context: ExecutionContext): Promise<void>;
+    /**
+     * Setup Terraform variables from config
+     * Converts config.variables to TF_VAR_* environment variables
+     * Does NOT convert .env file variables to TF_VAR_*
+     * @param config - Terraflow configuration
+     */
+    static setupTerraformVariables(config: TerraflowConfig): void;
+    /**
+     * Setup logging configuration
+     * Sets Terraform log level if configured
+     * @param config - Terraflow configuration
+     */
+    static setupLogging(config: TerraflowConfig): void;
+    /**
+     * Resolve template variables in config recursively
+     * Uses template vars from context
+     * @param config - Terraflow configuration to resolve templates in
+     * @param context - Execution context with template variables
+     * @returns Configuration with templates resolved
+     */
+    static resolveTemplateVars(config: TerraflowConfig, context: ExecutionContext): TerraflowConfig;
+    /**
+     * Setup complete environment
+     * Executes all environment setup steps in order
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @returns Updated context with environment setup complete
+     */
+    static setup(config: TerraflowConfig, context: ExecutionContext): Promise<ExecutionContext>;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/core/environment.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Environment setup
+ * Sets up cloud, VCS, and Terraform environment
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentSetup = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const dotenv_1 = require("dotenv");
+const cloud_1 = require("../utils/cloud");
+const logger_1 = require("../utils/logger");
+const templates_1 = require("../utils/templates");
+/**
+ * Environment setup utilities
+ */
+class EnvironmentSetup {
+    /**
+     * Load .env file from working directory
+     * Does NOT auto-convert to TF_VAR_* - only loads general environment variables
+     * @param workingDir - Working directory path
+     * @returns Record of environment variables from .env file
+     */
+    static loadEnvFile(workingDir) {
+        const envPath = (0, path_1.join)(workingDir, '.env');
+        if (!(0, fs_1.existsSync)(envPath)) {
+            return {};
+        }
+        try {
+            const envContent = (0, fs_1.readFileSync)(envPath, 'utf8');
+            const parsed = (0, dotenv_1.parse)(envContent);
+            // Set environment variables in process.env (but don't convert to TF_VAR_*)
+            for (const key in parsed) {
+                if (Object.prototype.hasOwnProperty.call(parsed, key)) {
+                    const value = parsed[key];
+                    if (value !== undefined && process.env[key] === undefined) {
+                        // Only set if not already in process.env (env takes precedence)
+                        process.env[key] = value;
+                    }
+                }
+            }
+            return parsed;
+        }
+        catch (error) {
+            logger_1.Logger.warn(`Failed to load .env file from ${workingDir}: ${error instanceof Error ? error.message : String(error)}`);
+            return {};
+        }
+    }
+    /**
+     * Setup cloud provider environment (AWS, Azure, GCP)
+     * - Syncs AWS_REGION and AWS_DEFAULT_REGION
+     * - Fetches account/subscription/project IDs
+     * @returns Updated cloud info
+     */
+    static async setupCloud() {
+        const cloud = await cloud_1.CloudUtils.detectCloud();
+        // Sync AWS region if AWS provider detected
+        if (cloud.provider === 'aws') {
+            const region = cloud_1.CloudUtils.getAwsRegion();
+            cloud.awsRegion = region;
+        }
+        return cloud;
+    }
+    /**
+     * Setup VCS environment (git variables)
+     * Sets GitHub Actions and GitLab CI compatible variables
+     * @param context - Execution context
+     * @returns Updated context with VCS environment variables
+     */
+    static async setupVcs(context) {
+        const { vcs } = context;
+        // Set basic git variables
+        if (vcs.branch) {
+            process.env.GIT_BRANCH = vcs.branch;
+        }
+        if (vcs.tag) {
+            process.env.GIT_TAG = vcs.tag;
+        }
+        if (vcs.commitSha) {
+            process.env.GIT_COMMIT_SHA = vcs.commitSha;
+            process.env.GIT_SHORT_SHA = vcs.shortSha || vcs.commitSha.substring(0, 7);
+        }
+        // Simulate GitHub Actions variables
+        if (vcs.githubRepository) {
+            process.env.GITHUB_REPOSITORY = vcs.githubRepository;
+            if (vcs.branch) {
+                process.env.GITHUB_REF = `refs/heads/${vcs.branch}`;
+            }
+            else if (vcs.tag) {
+                process.env.GITHUB_REF = `refs/tags/${vcs.tag}`;
+            }
+            if (vcs.commitSha) {
+                process.env.GITHUB_SHA = vcs.commitSha;
+            }
+        }
+        // Simulate GitLab CI variables
+        if (vcs.gitlabProjectPath) {
+            process.env.GITLAB_PROJECT_PATH = vcs.gitlabProjectPath;
+            if (vcs.branch) {
+                process.env.CI_COMMIT_REF_NAME = vcs.branch;
+            }
+            else if (vcs.tag) {
+                process.env.CI_COMMIT_REF_NAME = vcs.tag;
+            }
+            if (vcs.commitSha) {
+                process.env.CI_COMMIT_SHA = vcs.commitSha;
+                process.env.CI_COMMIT_SHORT_SHA = vcs.shortSha || vcs.commitSha.substring(0, 7);
+            }
+        }
+    }
+    /**
+     * Setup Terraform variables from config
+     * Converts config.variables to TF_VAR_* environment variables
+     * Does NOT convert .env file variables to TF_VAR_*
+     * @param config - Terraflow configuration
+     */
+    static setupTerraformVariables(config) {
+        if (!config.variables || typeof config.variables !== 'object') {
+            return;
+        }
+        for (const key in config.variables) {
+            if (Object.prototype.hasOwnProperty.call(config.variables, key)) {
+                const value = config.variables[key];
+                const envVarName = `TF_VAR_${key}`;
+                // Only set if not already in environment (env takes precedence)
+                if (process.env[envVarName] === undefined) {
+                    if (value === null || value === undefined) {
+                        process.env[envVarName] = '';
+                    }
+                    else if (typeof value === 'string') {
+                        process.env[envVarName] = value;
+                    }
+                    else {
+                        // Convert objects/arrays to JSON string
+                        process.env[envVarName] = JSON.stringify(value);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Setup logging configuration
+     * Sets Terraform log level if configured
+     * @param config - Terraflow configuration
+     */
+    static setupLogging(config) {
+        const logging = config.logging;
+        if (!logging) {
+            return;
+        }
+        // Set Terraform log level
+        if (logging.terraform_log_level) {
+            process.env.TF_LOG = logging.terraform_log_level;
+        }
+        // Enable/disable Terraform log
+        if (logging.terraform_log !== undefined) {
+            if (!logging.terraform_log) {
+                // Disable terraform logging
+                delete process.env.TF_LOG;
+            }
+            else if (!process.env.TF_LOG) {
+                // Enable with default level if not set
+                process.env.TF_LOG = logging.terraform_log_level || 'INFO';
+            }
+        }
+    }
+    /**
+     * Resolve template variables in config recursively
+     * Uses template vars from context
+     * @param config - Terraflow configuration to resolve templates in
+     * @param context - Execution context with template variables
+     * @returns Configuration with templates resolved
+     */
+    static resolveTemplateVars(config, context) {
+        // Cast to Record<string, unknown> for template resolution
+        const configRecord = config;
+        const resolved = templates_1.TemplateUtils.resolveObject(configRecord, context.templateVars);
+        return resolved;
+    }
+    /**
+     * Setup complete environment
+     * Executes all environment setup steps in order
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @returns Updated context with environment setup complete
+     */
+    static async setup(config, context) {
+        // 1. Load .env file (bootstrap credentials)
+        EnvironmentSetup.loadEnvFile(context.workingDir);
+        // 2. Setup cloud environment (detect account IDs, regions)
+        const cloud = await EnvironmentSetup.setupCloud();
+        context.cloud = cloud;
+        // 3. Setup VCS environment (git branch, commit, repository)
+        await EnvironmentSetup.setupVcs(context);
+        // 4. Resolve template variables in config
+        const resolvedConfig = EnvironmentSetup.resolveTemplateVars(config, context);
+        // 5. Setup Terraform variables from config
+        EnvironmentSetup.setupTerraformVariables(resolvedConfig);
+        // 6. Setup logging configuration
+        EnvironmentSetup.setupLogging(resolvedConfig);
+        return context;
+    }
+}
+exports.EnvironmentSetup = EnvironmentSetup;
+//# sourceMappingURL=environment.js.map

package/dist/core/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Custom error classes for Terraflow
+ */
+/**
+ * Base error class for Terraflow errors
+ */
+export declare class TerraflowError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validation error - thrown when validation fails
+ */
+export declare class ValidationError extends TerraflowError {
+    constructor(message: string);
+}
+/**
+ * Configuration error - thrown when configuration is invalid
+ */
+export declare class ConfigError extends TerraflowError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Custom error classes for Terraflow
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = exports.ValidationError = exports.TerraflowError = void 0;
+/**
+ * Base error class for Terraflow errors
+ */
+class TerraflowError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.TerraflowError = TerraflowError;
+/**
+ * Validation error - thrown when validation fails
+ */
+class ValidationError extends TerraflowError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Configuration error - thrown when configuration is invalid
+ */
+class ConfigError extends TerraflowError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ConfigError = ConfigError;
+//# sourceMappingURL=errors.js.map

package/dist/core/plugin-loader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Plugin loader
+ * Convention-based plugin discovery and loading
+ */
+import type { BackendPlugin, SecretsPlugin, AuthPlugin } from '../types/plugins';
+/**
+ * Load backend plugin by name
+ * Convention: src/plugins/backends/{name}.ts exports {name}Backend
+ */
+export declare function loadBackendPlugin(name: string): Promise<BackendPlugin>;
+/**
+ * Load secrets plugin by name
+ * Convention: src/plugins/secrets/{name}.ts exports {name}Secrets or {name}SecretManager
+ */
+export declare function loadSecretsPlugin(name: string): Promise<SecretsPlugin>;
+/**
+ * Load auth plugin by name
+ * Convention: src/plugins/auth/{name}.ts exports {name}Auth or camelCase version
+ */
+export declare function loadAuthPlugin(name: string): Promise<AuthPlugin>;
+//# sourceMappingURL=plugin-loader.d.ts.map

package/dist/core/plugin-loader.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Plugin loader
+ * Convention-based plugin discovery and loading
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBackendPlugin = loadBackendPlugin;
+exports.loadSecretsPlugin = loadSecretsPlugin;
+exports.loadAuthPlugin = loadAuthPlugin;
+/**
+ * Load backend plugin by name
+ * Convention: src/plugins/backends/{name}.ts exports {name}Backend
+ */
+async function loadBackendPlugin(name) {
+    try {
+        // Try to load the plugin module
+        const pluginModule = await Promise.resolve(`${`../plugins/backends/${name}.js`}`).then(s => __importStar(require(s)));
+        const pluginName = `${name}Backend`;
+        const plugin = pluginModule[pluginName];
+        if (!plugin) {
+            throw new Error(`Backend plugin "${name}" not found. Expected export "${pluginName}" from src/plugins/backends/${name}.ts`);
+        }
+        return plugin;
+    }
+    catch (error) {
+        throw new Error(`Failed to load backend plugin "${name}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load secrets plugin by name
+ * Convention: src/plugins/secrets/{name}.ts exports {name}Secrets or {name}SecretManager
+ */
+async function loadSecretsPlugin(name) {
+    try {
+        const pluginModule = await Promise.resolve(`${`../plugins/secrets/${name}.js`}`).then(s => __importStar(require(s)));
+        // Try common naming patterns based on actual plugin exports
+        // env -> envSecrets, aws-secrets -> awsSecrets, gcp-secret-manager -> gcpSecretManager
+        const pluginName1 = name === 'env'
+            ? 'envSecrets'
+            : name === 'aws-secrets'
+                ? 'awsSecrets'
+                : name === 'gcp-secret-manager'
+                    ? 'gcpSecretManager'
+                    : name === 'azure-keyvault'
+                        ? 'azureKeyvault'
+                        : `${name}Secrets`;
+        const plugin = pluginModule[pluginName1];
+        if (!plugin) {
+            // Try to find any exported object with a 'name' property matching our plugin name
+            for (const key in pluginModule) {
+                const exported = pluginModule[key];
+                if (exported &&
+                    typeof exported === 'object' &&
+                    'name' in exported &&
+                    exported.name === name) {
+                    return exported;
+                }
+            }
+            throw new Error(`Secrets plugin "${name}" not found. Expected export "${pluginName1}" from src/plugins/secrets/${name}.ts`);
+        }
+        return plugin;
+    }
+    catch (error) {
+        throw new Error(`Failed to load secrets plugin "${name}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load auth plugin by name
+ * Convention: src/plugins/auth/{name}.ts exports {name}Auth or camelCase version
+ */
+async function loadAuthPlugin(name) {
+    try {
+        const pluginModule = await Promise.resolve(`${`../plugins/auth/${name}.js`}`).then(s => __importStar(require(s)));
+        // Try common naming patterns based on actual plugin exports
+        // aws-assume-role -> awsAssumeRole
+        const pluginName1 = name === 'aws-assume-role'
+            ? 'awsAssumeRole'
+            : name === 'azure-service-principal'
+                ? 'azureServicePrincipal'
+                : name === 'gcp-service-account'
+                    ? 'gcpServiceAccount'
+                    : `${name}Auth`;
+        const plugin = pluginModule[pluginName1];
+        if (!plugin) {
+            // Try to find any exported object with a 'name' property matching our plugin name
+            for (const key in pluginModule) {
+                const exported = pluginModule[key];
+                if (exported &&
+                    typeof exported === 'object' &&
+                    'name' in exported &&
+                    exported.name === name) {
+                    return exported;
+                }
+            }
+            throw new Error(`Auth plugin "${name}" not found. Expected export "${pluginName1}" from src/plugins/auth/${name}.ts`);
+        }
+        return plugin;
+    }
+    catch (error) {
+        throw new Error(`Failed to load auth plugin "${name}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=plugin-loader.js.map

package/dist/core/terraform.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Terraform executor
+ * Executes terraform commands with proper environment setup
+ */
+import type { TerraflowConfig } from '../types/config';
+import type { ExecutionContext } from '../types/context';
+/**
+ * Terraform executor for running terraform commands
+ */
+export declare class TerraformExecutor {
+    /**
+     * Execute full terraform workflow
+     * @param command - Terraform command (e.g., 'plan', 'apply', 'destroy')
+     * @param args - Additional terraform arguments
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @param options - Execution options
+     */
+    static execute(command: string, args: string[], config: TerraflowConfig, context: ExecutionContext, options?: {
+        skipCommitCheck?: boolean;
+        dryRun?: boolean;
+    }): Promise<void>;
+    /**
+     * Initialize terraform with backend configuration
+     * For local backend, runs terraform init without backend-config flags
+     * @param backendType - Backend type (e.g., 'local', 's3', 'azurerm', 'gcs')
+     * @param backendArgs - Backend configuration arguments (-backend-config flags)
+     * @param workingDir - Terraform working directory
+     */
+    static init(backendType: string, backendArgs: string[], workingDir: string): Promise<void>;
+    /**
+     * Select or create workspace
+     * @param workspaceName - Workspace name
+     * @param workingDir - Terraform working directory
+     */
+    static workspace(workspaceName: string, workingDir: string): Promise<void>;
+    /**
+     * Execute terraform command
+     * @param command - Terraform command (e.g., 'plan', 'apply', 'destroy')
+     * @param args - Additional terraform arguments
+     * @param workingDir - Terraform working directory
+     */
+    static runCommand(command: string, args: string[], workingDir: string): Promise<void>;
+}
+//# sourceMappingURL=terraform.d.ts.map