@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.47

package/frigg-cli/deploy-command/index.js

@@ -1,175 +0,0 @@
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-// Configuration constants
-const PATHS = {
-    APP_DEFINITION: 'index.js',
-    INFRASTRUCTURE: 'infrastructure.js'
-};
-
-const COMMANDS = {
-    SERVERLESS: 'serverless'
-};
-
-/**
- * Constructs filtered environment variables for serverless deployment
- * @param {string[]} appDefinedVariables - Array of environment variable names from app definition
- * @returns {Object} Filtered environment variables object
- */
-function buildFilteredEnvironment(appDefinedVariables) {
-    return {
-        // Essential system variables needed to run serverless
-        PATH: process.env.PATH,
-        HOME: process.env.HOME,
-        USER: process.env.USER,
-
-        // AWS credentials and configuration (all AWS_ prefixed variables)
-        ...Object.fromEntries(
-            Object.entries(process.env).filter(([key]) =>
-                key.startsWith('AWS_')
-            )
-        ),
-
-        // App-defined environment variables
-        ...Object.fromEntries(
-            appDefinedVariables
-                .map((key) => [key, process.env[key]])
-                .filter(([_, value]) => value !== undefined)
-        ),
-    };
-}
-
-/**
- * Loads and parses the app definition from index.js
- * @returns {Object|null} App definition object or null if not found
- */
-function loadAppDefinition() {
-    const appDefPath = path.join(process.cwd(), PATHS.APP_DEFINITION);
-    
-    if (!fs.existsSync(appDefPath)) {
-        return null;
-    }
-
-    try {
-        const { Definition } = require(appDefPath);
-        return Definition;
-    } catch (error) {
-        console.warn('Could not load appDefinition environment config:', error.message);
-        return null;
-    }
-}
-
-/**
- * Extracts environment variable names from app definition
- * @param {Object} appDefinition - App definition object
- * @returns {string[]} Array of environment variable names
- */
-function extractEnvironmentVariables(appDefinition) {
-    if (!appDefinition?.environment) {
-        return [];
-    }
-
-    console.log('🔧 Loading environment configuration from appDefinition...');
-    
-    const appDefinedVariables = Object.keys(appDefinition.environment).filter(
-        (key) => appDefinition.environment[key] === true
-    );
-
-    console.log(`   Found ${appDefinedVariables.length} environment variables: ${appDefinedVariables.join(', ')}`);
-    return appDefinedVariables;
-}
-
-/**
- * Handles environment validation warnings
- * @param {Object} validation - Validation result object
- * @param {Object} options - Deploy command options
- */
-function handleValidationWarnings(validation, options) {
-    if (validation.missing.length === 0 || options.skipEnvValidation) {
-        return;
-    }
-
-    console.warn(`⚠️  Warning: Missing ${validation.missing.length} environment variables: ${validation.missing.join(', ')}`);
-    console.warn('   These variables are optional and deployment will continue');
-    console.warn('   Run with --skip-env-validation to bypass this check');
-}
-
-/**
- * Validates environment variables and builds filtered environment
- * @param {Object} appDefinition - App definition object
- * @param {Object} options - Deploy command options
- * @returns {Object} Filtered environment variables
- */
-function validateAndBuildEnvironment(appDefinition, options) {
-    if (!appDefinition) {
-        return buildFilteredEnvironment([]);
-    }
-
-    const appDefinedVariables = extractEnvironmentVariables(appDefinition);
-
-    // Try to use the env-validator if available
-    try {
-        const { validateEnvironmentVariables } = require('@friggframework/devtools/infrastructure/env-validator');
-        const validation = validateEnvironmentVariables(appDefinition);
-
-        handleValidationWarnings(validation, options);
-        return buildFilteredEnvironment(appDefinedVariables);
-
-    } catch (validatorError) {
-        // Validator not available, do basic validation
-        const missingVariables = appDefinedVariables.filter((variable) => !process.env[variable]);
-        
-        if (missingVariables.length > 0) {
-            console.warn(`⚠️  Warning: Missing ${missingVariables.length} environment variables: ${missingVariables.join(', ')}`);
-            console.warn('   These variables are optional and deployment will continue');
-            console.warn('   Set them in your CI/CD environment or .env file if needed');
-        }
-
-        return buildFilteredEnvironment(appDefinedVariables);
-    }
-}
-
-/**
- * Executes the serverless deployment command
- * @param {Object} environment - Environment variables to pass to serverless
- * @param {Object} options - Deploy command options
- */
-function executeServerlessDeployment(environment, options) {
-    console.log('🚀 Deploying serverless application...');
-    
-    const serverlessArgs = [
-        'deploy',
-        '--config',
-        PATHS.INFRASTRUCTURE,
-        '--stage',
-        options.stage,
-    ];
-
-    const childProcess = spawn(COMMANDS.SERVERLESS, serverlessArgs, {
-        cwd: path.resolve(process.cwd()),
-        stdio: 'inherit',
-        env: environment,
-    });
-
-    childProcess.on('error', (error) => {
-        console.error(`Error executing command: ${error.message}`);
-    });
-
-    childProcess.on('close', (code) => {
-        if (code !== 0) {
-            console.log(`Child process exited with code ${code}`);
-        }
-    });
-}
-
-async function deployCommand(options) {
-    console.log('Deploying the serverless application...');
-
-    const appDefinition = loadAppDefinition();
-    const environment = validateAndBuildEnvironment(appDefinition, options);
-    
-    executeServerlessDeployment(environment, options);
-}
-
-module.exports = { deployCommand };

package/frigg-cli/generate-command/__tests__/generate-command.test.js

@@ -1,301 +0,0 @@
-const path = require('path');
-
-/**
- * Test suite for generate command
- *
- * Tests the ACTUAL Frigg template generation implementation:
- * - CloudFormation template generation (REAL - tests actual YAML syntax)
- * - Terraform template generation (REAL - tests actual HCL syntax)
- * - Azure ARM template generation (REAL - tests actual JSON syntax)
- * - GCP Deployment Manager (REAL - tests actual YAML syntax)
- * - File system operations (MOCKED - external I/O boundary)
- * - Package discovery (MOCKED - external boundary)
- * - Interactive prompts (MOCKED - external boundary)
- *
- * REFACTORED: CloudFormation generator now uses same API as Terraform generator
- * ==============================================================================
- * Fixed export name and aligned API signatures:
- * - Added generateCloudFormationTemplate alias export
- * - Refactored to accept flattened options: { appName, features, userPrefix, stackName }
- * - Consistent with Terraform generator pattern
- * - All callers updated to use getFeatureSummary(appDefinition)
- */
-
-// Mock ONLY external boundaries - let template generators run!
-jest.mock('fs', () => ({
-    readFileSync: jest.fn(),
-    existsSync: jest.fn(),
-    mkdirSync: jest.fn(),
-    writeFileSync: jest.fn()
-}));
-jest.mock('../../utils/backend-path', () => ({
-    findNearestBackendPackageJson: jest.fn()  // External: file system discovery
-}));
-jest.mock('@inquirer/prompts', () => ({
-    select: jest.fn()  // External: interactive user input
-}));
-
-// DON'T mock these - let them run to test actual template generation:
-// - generateCloudFormationTemplate (tests YAML syntax)
-// - generateTerraformTemplate (tests HCL syntax)
-// - generateAzureARMTemplate (tests JSON syntax)
-// - generateGCPDeploymentManagerTemplate (tests YAML syntax)
-
-// Require after mocks
-const fs = require('fs');
-const { findNearestBackendPackageJson } = require('../../utils/backend-path');
-const { select } = require('@inquirer/prompts');
-const generateCommand = require('../index');
-
-// NOTE: We test via generateCommand() which internally uses the real generators
-// No need to import generators directly - they run when generateCommand() is called
-
-describe('Generate Command', () => {
-    const mockBackendDir = '/mock/backend';
-    const mockPackageJsonPath = path.join(mockBackendDir, 'package.json');
-    const mockAppDefinitionPath = path.join(mockBackendDir, 'index.js');
-    
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        // Mock process.exit
-        jest.spyOn(process, 'exit').mockImplementation(() => {});
-
-        // Mock console methods
-        jest.spyOn(console, 'log').mockImplementation(() => {});
-        jest.spyOn(console, 'error').mockImplementation(() => {});
-
-        // Re-setup mocks after clearAllMocks
-        findNearestBackendPackageJson.mockResolvedValue(mockPackageJsonPath);
-
-        // Re-setup fs mock implementations
-        fs.readFileSync.mockImplementation((filePath, encoding) => {
-            // Normalize path to handle different separators
-            const normalizedPath = filePath.toString();
-
-            if (normalizedPath === mockPackageJsonPath || normalizedPath.endsWith('backend/package.json')) {
-                return JSON.stringify({ name: 'test-app' });
-            }
-
-            // For any other file, throw ENOENT like real fs would
-            const error = new Error(`ENOENT: no such file or directory, open '${filePath}'`);
-            error.code = 'ENOENT';
-            throw error;
-        });
-
-        fs.existsSync.mockImplementation((filePath) => {
-            if (filePath === mockAppDefinitionPath) {
-                return true;
-            }
-            if (filePath.includes('backend/infrastructure')) {
-                return false; // Directory doesn't exist, will be created
-            }
-            return true;
-        });
-
-        fs.mkdirSync.mockImplementation(() => {});
-        fs.writeFileSync.mockImplementation(() => {});
-
-        // Mock the app definition module
-        const mockAppDefinition = {
-            vpc: { enable: true },
-            encryption: { fieldLevelEncryptionMethod: 'kms' },
-            ssm: { enable: true },
-            websockets: { enable: false }
-        };
-
-        // Use jest.doMock to mock the dynamic require
-        jest.doMock(mockAppDefinitionPath, () => mockAppDefinition, { virtual: true });
-    });
-    
-    afterEach(() => {
-        jest.restoreAllMocks();
-
-        // Clean up the mock
-        jest.dontMock(mockAppDefinitionPath);
-    });
-    
-    describe('AWS CloudFormation Generation', () => {
-        it('should generate valid CloudFormation template with actual YAML syntax', async () => {
-            await generateCommand({
-                provider: 'aws',
-                format: 'cloudformation',
-                output: 'backend/infrastructure',
-                user: 'test-user',
-                stackName: 'test-stack'
-            });
-
-            // Verify file was written with correct path
-            expect(fs.writeFileSync).toHaveBeenCalledWith(
-                expect.stringContaining('frigg-deployment-aws-cloudformation.yaml'),
-                expect.any(String)
-            );
-
-            // Get the actual generated template content
-            const writeCall = fs.writeFileSync.mock.calls.find(call =>
-                call[0].includes('frigg-deployment-aws-cloudformation.yaml')
-            );
-
-            expect(writeCall).toBeDefined();
-            const [filePath, generatedTemplate] = writeCall;
-
-            // Verify template has valid CloudFormation YAML structure
-            expect(generatedTemplate).toContain('AWSTemplateFormatVersion: \'2010-09-09\'');
-            expect(generatedTemplate).toContain('Description:');
-            expect(generatedTemplate).toContain('Resources:');
-
-            // Verify IAM user resource exists
-            expect(generatedTemplate).toContain('Type: AWS::IAM::User');
-
-            // Verify feature-based policies are included (uses ManagedPolicy, not Policy)
-            expect(generatedTemplate).toContain('AWS::IAM::ManagedPolicy'); // Managed policies
-            expect(generatedTemplate).toContain('kms:'); // KMS permissions
-            expect(generatedTemplate).toContain('ssm:'); // SSM permissions (via parameters)
-
-            // Verify no WebSocket permissions (websockets: false in mock)
-            expect(generatedTemplate).not.toContain('execute-api:ManageConnections');
-
-            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('✅ Generated cloudformation template for aws'));
-        });
-        
-        it('should handle missing app definition gracefully', async () => {
-            fs.existsSync.mockImplementation((filePath) => {
-                if (filePath === mockAppDefinitionPath) {
-                    return false;
-                }
-                return true;
-            });
-            
-            await generateCommand({
-                provider: 'aws',
-                format: 'cloudformation'
-            });
-            
-            expect(console.error).toHaveBeenCalledWith(
-                'Error generating deployment credentials:',
-                expect.stringContaining('App definition not found')
-            );
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-    });
-    
-    describe('AWS Terraform Generation', () => {
-        it('should generate valid Terraform template with actual HCL syntax', async () => {
-            await generateCommand({
-                provider: 'aws',
-                format: 'terraform',
-                output: 'backend/infrastructure'
-            });
-
-            // Verify file was written with correct path
-            expect(fs.writeFileSync).toHaveBeenCalledWith(
-                expect.stringContaining('frigg-deployment-aws-terraform.tf'),
-                expect.any(String)
-            );
-
-            // Get the actual generated template content
-            const writeCall = fs.writeFileSync.mock.calls.find(call =>
-                call[0].includes('frigg-deployment-aws-terraform.tf')
-            );
-
-            expect(writeCall).toBeDefined();
-            const [filePath, generatedTemplate] = writeCall;
-
-            // Verify template has valid Terraform HCL structure
-            expect(generatedTemplate).toContain('terraform {');
-            expect(generatedTemplate).toContain('required_providers {');
-            expect(generatedTemplate).toContain('source  = "hashicorp/aws"'); // AWS provider config
-
-            // Verify IAM user resource exists
-            expect(generatedTemplate).toContain('resource "aws_iam_user"');
-
-            // Verify feature variables are defined
-            expect(generatedTemplate).toContain('variable "enable_vpc"');
-            expect(generatedTemplate).toContain('variable "enable_kms"');
-            expect(generatedTemplate).toContain('variable "enable_ssm"');
-
-            // Verify feature-based policies
-            expect(generatedTemplate).toContain('resource "aws_iam_policy"');
-
-            // Verify brace matching (valid HCL syntax)
-            const openBraces = (generatedTemplate.match(/{/g) || []).length;
-            const closeBraces = (generatedTemplate.match(/}/g) || []).length;
-            expect(openBraces).toBe(closeBraces);
-        });
-    });
-    
-    // TODO: Update Azure/GCP tests to follow same pattern as CloudFormation/Terraform
-    // Skipping for now to focus on core AWS templates
-    describe.skip('Azure Generators', () => {
-        it('should generate ARM template for Azure', async () => {
-            // Test disabled - needs update to test actual generator output
-        });
-
-        it('should generate Terraform template for Azure', async () => {
-            // Test disabled - needs update to test actual generator output
-        });
-    });
-    
-    describe.skip('GCP Generators', () => {
-        it('should generate Deployment Manager template for GCP', async () => {
-            // Test disabled - needs update to test actual generator output
-        });
-
-        it('should generate Terraform template for GCP', async () => {
-            // Test disabled - needs update to test actual generator output
-        });
-    });
-    
-    describe.skip('Interactive Mode', () => {
-        it('should prompt for provider and format when not provided', async () => {
-            // Test disabled - needs update to work with unmocked generators
-        });
-
-        it('should handle user cancellation gracefully', async () => {
-            // Test disabled - needs update to work with unmocked generators
-        });
-    });
-    
-    describe('Error Handling', () => {
-        it('should handle missing Frigg application', async () => {
-            findNearestBackendPackageJson.mockResolvedValue(null);
-            
-            await generateCommand({
-                provider: 'aws',
-                format: 'cloudformation'
-            });
-            
-            expect(console.error).toHaveBeenCalledWith(
-                'Error generating deployment credentials:',
-                'Could not find a Frigg application. Make sure you are in a Frigg project directory.'
-            );
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        
-        it('should show stack trace in verbose mode', async () => {
-            const error = new Error('Test error');
-            error.stack = 'Error: Test error\n    at testFunction';
-            findNearestBackendPackageJson.mockRejectedValue(error);
-            
-            await generateCommand({
-                provider: 'aws',
-                format: 'cloudformation',
-                verbose: true
-            });
-            
-            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('at testFunction'));
-        });
-        
-        it('should handle unsupported formats', async () => {
-            await generateCommand({
-                provider: 'aws',
-                format: 'pulumi'
-            });
-            
-            expect(console.error).toHaveBeenCalledWith(
-                'Error generating deployment credentials:',
-                'Pulumi support is not yet implemented'
-            );
-        });
-    });
-});

package/frigg-cli/generate-command/azure-generator.js

@@ -1,43 +0,0 @@
-async function generateAzureARMTemplate(options) {
-    const { appName, features, userPrefix } = options;
-    
-    // Placeholder for Azure ARM template generation
-    const template = {
-        "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
-        "contentVersion": "1.0.0.0",
-        "metadata": {
-            "description": "Frigg deployment credentials for Azure - Coming Soon",
-            "author": "Frigg CLI"
-        },
-        "parameters": {},
-        "variables": {},
-        "resources": [],
-        "outputs": {
-            "message": {
-                "type": "string",
-                "value": "Azure ARM template generation is coming soon. Please use Terraform for now."
-            }
-        }
-    };
-
-    return JSON.stringify(template, null, 2);
-}
-
-async function generateAzureTerraformTemplate(options) {
-    // Placeholder for Azure Terraform template
-    return `# Frigg Deployment Configuration for Azure
-# Coming Soon
-
-# Azure support with Terraform is under development.
-# Please check back in a future release.
-
-output "message" {
-  value = "Azure Terraform support is coming soon"
-}
-`;
-}
-
-module.exports = {
-    generateAzureARMTemplate,
-    generateAzureTerraformTemplate
-};

package/frigg-cli/generate-command/gcp-generator.js

@@ -1,47 +0,0 @@
-async function generateGCPDeploymentManagerTemplate(options) {
-    const { appName, features, userPrefix } = options;
-    
-    // Placeholder for GCP Deployment Manager template
-    const template = `# Frigg Deployment Configuration for Google Cloud Platform
-# Coming Soon
-
-# GCP Deployment Manager support is under development.
-# Please use Terraform for GCP deployments in the meantime.
-
-resources: []
-
-outputs:
-- name: message
-  value: "GCP Deployment Manager support is coming soon"
-`;
-
-    return template;
-}
-
-async function generateGCPTerraformTemplate(options) {
-    // Placeholder for GCP Terraform template
-    return `# Frigg Deployment Configuration for Google Cloud Platform
-# Coming Soon
-
-terraform {
-  required_providers {
-    google = {
-      source  = "hashicorp/google"
-      version = "~> 5.0"
-    }
-  }
-}
-
-# GCP support with Terraform is under development.
-# Please check back in a future release.
-
-output "message" {
-  value = "GCP Terraform support is coming soon"
-}
-`;
-}
-
-module.exports = {
-    generateGCPDeploymentManagerTemplate,
-    generateGCPTerraformTemplate
-};