@salte-common/terraflow 0.1.0-alpha.1

package/dist/utils/scaffolding.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * Scaffolding utilities for project initialization
+ * Handles template processing and file generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplate = loadTemplate;
+exports.processTemplate = processTemplate;
+exports.generateTerraformFiles = generateTerraformFiles;
+exports.generateApplicationFiles = generateApplicationFiles;
+exports.generateConfigFiles = generateConfigFiles;
+exports.createProjectStructure = createProjectStructure;
+exports.validateProjectName = validateProjectName;
+exports.validateProvider = validateProvider;
+exports.validateLanguage = validateLanguage;
+exports.isDirectoryEmpty = isDirectoryEmpty;
+exports.buildTemplateVariables = buildTemplateVariables;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_1 = require("./logger");
+const errors_1 = require("../core/errors");
+/**
+ * Template processing functions
+ */
+/**
+ * Load a template file from the templates directory
+ * @param templatePath - Path to template file relative to templates directory
+ * @returns Template content as string
+ */
+function loadTemplate(templatePath) {
+    // Get template directory (works in both source and built code)
+    const templatesDir = (0, path_1.join)(__dirname, '..', 'templates');
+    // Prevent path traversal attacks
+    // Reject any path that contains path traversal sequences
+    if (templatePath.includes('..') || templatePath.includes('~')) {
+        throw new errors_1.ConfigError(`Invalid template path: ${templatePath}`);
+    }
+    // Join and resolve to get absolute path, then verify it's within templates directory
+    const fullPath = (0, path_1.join)(templatesDir, templatePath);
+    // Additional safety: verify the resolved path is within templates directory
+    // by checking that it starts with the templates directory path
+    if (!fullPath.startsWith(templatesDir)) {
+        throw new errors_1.ConfigError(`Invalid template path: ${templatePath}`);
+    }
+    try {
+        return (0, fs_1.readFileSync)(fullPath, 'utf8');
+    }
+    catch (error) {
+        logger_1.Logger.error(`Failed to load template ${templatePath}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new errors_1.ConfigError(`Template file not found: ${templatePath}.\n` +
+            `This may indicate a corrupted installation. Try reinstalling terraflow.`);
+    }
+}
+/**
+ * Process a template string by replacing variable placeholders
+ * @param template - Template content with placeholders
+ * @param variables - Object mapping variable names to values
+ * @returns Processed template with variables replaced
+ */
+function processTemplate(template, variables) {
+    let result = template;
+    for (const [key, value] of Object.entries(variables)) {
+        const regex = new RegExp(`<${key}>`, 'g');
+        result = result.replace(regex, value);
+    }
+    return result;
+}
+/**
+ * File generation functions
+ */
+/**
+ * Generate Terraform files for the project
+ * @param projectDir - Root directory of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param projectName - Name of the project
+ */
+async function generateTerraformFiles(projectDir, provider, projectName) {
+    const terraformDir = (0, path_1.join)(projectDir, 'terraform');
+    const templatesDir = 'terraform';
+    logger_1.Logger.debug(`Generating Terraform files for provider: ${provider}`);
+    // Create terraform directory if it doesn't exist
+    (0, fs_1.mkdirSync)(terraformDir, { recursive: true });
+    // _init.tf - provider-specific
+    const initTemplate = loadTemplate((0, path_1.join)(templatesDir, provider, '_init.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(terraformDir, '_init.tf'), initTemplate);
+    // inputs.tf - provider-specific
+    const inputsTemplate = loadTemplate((0, path_1.join)(templatesDir, provider, 'inputs.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(terraformDir, 'inputs.tf'), inputsTemplate);
+    // locals.tf - common with project name replacement
+    const localsTemplate = loadTemplate((0, path_1.join)(templatesDir, 'locals.tf.template'));
+    const localsContent = processTemplate(localsTemplate, { 'project-name': projectName });
+    (0, fs_1.writeFileSync)((0, path_1.join)(terraformDir, 'locals.tf'), localsContent);
+    // main.tf - common
+    const mainTemplate = loadTemplate((0, path_1.join)(templatesDir, 'main.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(terraformDir, 'main.tf'), mainTemplate);
+    // outputs.tf - common
+    const outputsTemplate = loadTemplate((0, path_1.join)(templatesDir, 'outputs.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(terraformDir, 'outputs.tf'), outputsTemplate);
+    // Create modules directory
+    const modulesDir = (0, path_1.join)(terraformDir, 'modules');
+    (0, fs_1.mkdirSync)(modulesDir, { recursive: true });
+    // modules/inputs.tf
+    const moduleInputsTemplate = loadTemplate((0, path_1.join)(templatesDir, 'modules', 'inputs.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(modulesDir, 'inputs.tf'), moduleInputsTemplate);
+    // modules/main.tf
+    const moduleMainTemplate = loadTemplate((0, path_1.join)(templatesDir, 'modules', 'main.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(modulesDir, 'main.tf'), moduleMainTemplate);
+    // modules/outputs.tf
+    const moduleOutputsTemplate = loadTemplate((0, path_1.join)(templatesDir, 'modules', 'outputs.tf.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(modulesDir, 'outputs.tf'), moduleOutputsTemplate);
+    logger_1.Logger.debug('Terraform files generated successfully');
+}
+/**
+ * Get file extension for main file based on language
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @returns File extension (e.g., '.js', '.ts', '.py', '.go')
+ * @example
+ * getMainExtension('typescript') // returns '.ts'
+ * getMainExtension('python') // returns '.py'
+ */
+function getMainExtension(language) {
+    switch (language) {
+        case 'typescript':
+            return '.ts';
+        case 'python':
+            return '.py';
+        case 'go':
+            return '.go';
+        default:
+            return '.js';
+    }
+}
+/**
+ * Get test file name based on language
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @returns Test file name (e.g., 'index.spec.js', 'test_main.py', 'main_test.go')
+ * @example
+ * getTestFileName('python') // returns 'test_main.py'
+ * getTestFileName('go') // returns 'main_test.go'
+ */
+function getTestFileName(language) {
+    switch (language) {
+        case 'python':
+            return 'test_main.py';
+        case 'go':
+            return 'main_test.go';
+        case 'typescript':
+            return 'index.spec.ts';
+        default:
+            return 'index.spec.js';
+    }
+}
+/**
+ * Generate application files for the project
+ * @param projectDir - Root directory of the project
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @param projectName - Name of the project
+ */
+async function generateApplicationFiles(projectDir, language, projectName) {
+    const srcDir = (0, path_1.join)(projectDir, 'src');
+    const templatesDir = 'application';
+    logger_1.Logger.debug(`Generating application files for language: ${language}`);
+    // Create src directories
+    (0, fs_1.mkdirSync)((0, path_1.join)(srcDir, 'main'), { recursive: true });
+    (0, fs_1.mkdirSync)((0, path_1.join)(srcDir, 'test'), { recursive: true });
+    // Main file
+    const mainTemplate = loadTemplate((0, path_1.join)(templatesDir, language, 'main.template'));
+    const mainContent = processTemplate(mainTemplate, { 'project-name': projectName });
+    const mainExt = getMainExtension(language);
+    (0, fs_1.writeFileSync)((0, path_1.join)(srcDir, 'main', `index${mainExt}`), mainContent);
+    // Test file
+    const testTemplate = loadTemplate((0, path_1.join)(templatesDir, language, 'test.template'));
+    const testContent = processTemplate(testTemplate, { 'project-name': projectName });
+    const testFileName = getTestFileName(language);
+    (0, fs_1.writeFileSync)((0, path_1.join)(srcDir, 'test', testFileName), testContent);
+    // Language-specific config files
+    if (language === 'typescript') {
+        const tsconfigTemplate = loadTemplate((0, path_1.join)(templatesDir, language, 'tsconfig.json.template'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, 'tsconfig.json'), tsconfigTemplate);
+    }
+    else if (language === 'python') {
+        const requirementsTemplate = loadTemplate((0, path_1.join)(templatesDir, language, 'requirements.txt.template'));
+        (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, 'requirements.txt'), requirementsTemplate);
+    }
+    else if (language === 'go') {
+        const goModTemplate = loadTemplate((0, path_1.join)(templatesDir, language, 'go.mod.template'));
+        const goModContent = processTemplate(goModTemplate, { 'project-name': projectName });
+        (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, 'go.mod'), goModContent);
+    }
+    logger_1.Logger.debug('Application files generated successfully');
+}
+/**
+ * Map cloud provider to Terraform backend type
+ * @param provider - Cloud provider name (aws, azure, gcp)
+ * @returns Backend type (s3, azurerm, gcs, or local)
+ * @example
+ * getBackendType('aws') // returns 's3'
+ * getBackendType('azure') // returns 'azurerm'
+ * getBackendType('gcp') // returns 'gcs'
+ */
+function getBackendType(provider) {
+    switch (provider) {
+        case 'aws':
+            return 's3';
+        case 'azure':
+            return 'azurerm';
+        case 'gcp':
+            return 'gcs';
+        default:
+            return 'local';
+    }
+}
+/**
+ * Generate configuration files for the project
+ * @param projectDir - Root directory of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @param projectName - Name of the project
+ */
+async function generateConfigFiles(projectDir, provider, language, projectName) {
+    const templatesDir = 'config';
+    logger_1.Logger.debug(`Generating configuration files for provider: ${provider}, language: ${language}`);
+    // .tfwconfig.yml
+    const tfwconfigTemplate = loadTemplate((0, path_1.join)(templatesDir, 'tfwconfig.yml.template'));
+    const backendType = getBackendType(provider);
+    const tfwconfigContent = processTemplate(tfwconfigTemplate, {
+        'project-name': projectName,
+        provider: backendType,
+    });
+    (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, '.tfwconfig.yml'), tfwconfigContent);
+    // .env.example
+    const envExampleTemplate = loadTemplate((0, path_1.join)(templatesDir, 'env.example.template'));
+    (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, '.env.example'), envExampleTemplate);
+    // .gitignore
+    const gitignoreTemplate = loadTemplate((0, path_1.join)(templatesDir, 'gitignore.template'));
+    // gitignore template already includes all languages, no processing needed
+    (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, '.gitignore'), gitignoreTemplate);
+    // README.md
+    const readmeTemplate = loadTemplate((0, path_1.join)(templatesDir, 'README.md.template'));
+    const readmeContent = processTemplate(readmeTemplate, {
+        'project-name': projectName,
+        provider: provider, // Use original provider name for README
+    });
+    (0, fs_1.writeFileSync)((0, path_1.join)(projectDir, 'README.md'), readmeContent);
+    logger_1.Logger.debug('Configuration files generated successfully');
+}
+/**
+ * Project structure creation
+ */
+/**
+ * Create the complete project directory structure
+ * @param projectDir - Root directory of the project
+ */
+async function createProjectStructure(projectDir) {
+    logger_1.Logger.debug(`Creating project structure in: ${projectDir}`);
+    const dirs = [
+        (0, path_1.join)(projectDir, 'src', 'main'),
+        (0, path_1.join)(projectDir, 'src', 'test'),
+        (0, path_1.join)(projectDir, 'terraform', 'modules'),
+    ];
+    for (const dir of dirs) {
+        try {
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        }
+        catch (error) {
+            logger_1.Logger.error(`Failed to create directory ${dir}: ${error instanceof Error ? error.message : String(error)}`);
+            throw new errors_1.ConfigError(`Failed to create directory: ${dir}`);
+        }
+    }
+    logger_1.Logger.debug('Project structure created successfully');
+}
+/**
+ * Validation helpers
+ */
+/**
+ * Validate project name format
+ * @param name - Project name to validate
+ * @returns true if valid, false otherwise
+ */
+function validateProjectName(name) {
+    const PROJECT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+    return PROJECT_NAME_REGEX.test(name);
+}
+/**
+ * Validate cloud provider
+ * @param provider - Provider name to validate
+ * @returns true if valid, false otherwise
+ */
+function validateProvider(provider) {
+    const VALID_PROVIDERS = ['aws', 'azure', 'gcp'];
+    return VALID_PROVIDERS.includes(provider);
+}
+/**
+ * Validate programming language
+ * @param language - Language name to validate
+ * @returns true if valid, false otherwise
+ */
+function validateLanguage(language) {
+    const VALID_LANGUAGES = ['javascript', 'typescript', 'python', 'go'];
+    return VALID_LANGUAGES.includes(language);
+}
+/**
+ * Check if a directory is empty
+ * @param dir - Directory path to check
+ * @returns true if directory is empty or doesn't exist, false otherwise
+ */
+async function isDirectoryEmpty(dir) {
+    if (!(0, fs_1.existsSync)(dir)) {
+        return true;
+    }
+    try {
+        const files = (0, fs_1.readdirSync)(dir);
+        return files.length === 0;
+    }
+    catch (error) {
+        logger_1.Logger.error(`Failed to read directory ${dir}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new errors_1.ConfigError(`Failed to read directory: ${dir}`);
+    }
+}
+/**
+ * Template variable builder
+ */
+/**
+ * Build template variables object from project parameters
+ * @param projectName - Name of the project
+ * @param provider - Cloud provider (aws, azure, gcp)
+ * @param language - Programming language (javascript, typescript, python, go)
+ * @returns Object with all template variable mappings
+ */
+function buildTemplateVariables(projectName, provider, _language) {
+    const backendType = getBackendType(provider);
+    return {
+        'project-name': projectName,
+        provider: backendType,
+        'provider-name': provider, // Keep original provider name for README
+    };
+}
+//# sourceMappingURL=scaffolding.js.map

package/dist/utils/templates.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Variable templating utility
+ * Resolves template variables in configuration
+ */
+/**
+ * Template resolution utility
+ */
+export declare class TemplateUtils {
+    /**
+     * Resolve template variables in a string
+     * Supports ${VAR} syntax
+     * @param template - Template string with ${VAR} placeholders
+     * @param vars - Variables to substitute
+     * @returns Resolved string
+     */
+    static resolve(template: string, vars: Record<string, string>): string;
+    /**
+     * Resolve all template variables in an object recursively
+     * @param obj - Object to resolve templates in
+     * @param vars - Variables to substitute
+     * @returns Object with templates resolved
+     */
+    static resolveObject<T extends Record<string, unknown>>(obj: T, vars: Record<string, string>): T;
+}
+//# sourceMappingURL=templates.d.ts.map

package/dist/utils/templates.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Variable templating utility
+ * Resolves template variables in configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateUtils = void 0;
+/**
+ * Template resolution utility
+ */
+class TemplateUtils {
+    /**
+     * Resolve template variables in a string
+     * Supports ${VAR} syntax
+     * @param template - Template string with ${VAR} placeholders
+     * @param vars - Variables to substitute
+     * @returns Resolved string
+     */
+    static resolve(template, vars) {
+        if (typeof template !== 'string') {
+            return template;
+        }
+        return template.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+            const trimmedVarName = varName.trim();
+            if (vars[trimmedVarName] !== undefined) {
+                return vars[trimmedVarName];
+            }
+            // If variable not found, return the original placeholder
+            return match;
+        });
+    }
+    /**
+     * Resolve all template variables in an object recursively
+     * @param obj - Object to resolve templates in
+     * @param vars - Variables to substitute
+     * @returns Object with templates resolved
+     */
+    static resolveObject(obj, vars) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (typeof obj === 'string') {
+            return TemplateUtils.resolve(obj, vars);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => TemplateUtils.resolveObject(item, vars));
+        }
+        if (typeof obj === 'object') {
+            const resolved = {};
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    const value = obj[key];
+                    if (typeof value === 'string') {
+                        resolved[key] = TemplateUtils.resolve(value, vars);
+                    }
+                    else if (typeof value === 'object' && value !== null) {
+                        resolved[key] = TemplateUtils.resolveObject(value, vars);
+                    }
+                    else {
+                        resolved[key] = value;
+                    }
+                }
+            }
+            return resolved;
+        }
+        return obj;
+    }
+}
+exports.TemplateUtils = TemplateUtils;
+//# sourceMappingURL=templates.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@salte-common/terraflow",
+  "version": "0.1.0-alpha.1",
+  "description": "Opinionated Terraform workflow CLI with multi-cloud support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "terraflow": "./bin/terraflow.js",
+    "tf": "./bin/tf.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-templates",
+    "copy-templates": "cp -r src/templates dist/templates",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "terraform",
+    "infrastructure",
+    "iac",
+    "devops",
+    "cli",
+    "aws",
+    "azure",
+    "gcp"
+  ],
+  "author": "Dave Sibiski",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/salte-common/terraflow.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-secrets-manager": "^3.956.0",
+    "@aws-sdk/client-sts": "^3.956.0",
+    "commander": "^11.0.0",
+    "dotenv": "^16.0.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "jest": "^29.0.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  }
+}