@friggframework/devtools 2.0.0--canary.398.7664c46.0 → 2.0.0--canary.400.bed3308.0

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

@@ -0,0 +1,47 @@
+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
+};

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

@@ -0,0 +1,350 @@
+const path = require('path');
+const fs = require('fs');
+const { findNearestBackendPackageJson } = require('../utils/backend-path');
+const { select } = require('@inquirer/prompts');
+
+// Import generators for different formats
+const { generateCloudFormationTemplate } = require('../../infrastructure/iam-generator');
+const { generateTerraformTemplate } = require('./terraform-generator');
+const { generateAzureARMTemplate, generateAzureTerraformTemplate } = require('./azure-generator');
+const { generateGCPDeploymentManagerTemplate, generateGCPTerraformTemplate } = require('./gcp-generator');
+
+async function generateCommand(options = {}) {
+    // Set up graceful exit handler
+    process.on('SIGINT', () => {
+        console.log('\n✖ Command cancelled by user');
+        process.exit(0);
+    });
+
+    try {
+        // Interactive mode: ask for cloud provider and format if not provided
+        if (!options.provider) {
+            try {
+                options.provider = await select({
+                    message: 'Select cloud provider:',
+                    choices: [
+                        { name: 'AWS', value: 'aws' },
+                        { name: 'Azure', value: 'azure' },
+                        { name: 'Google Cloud Platform', value: 'gcp' }
+                    ]
+                });
+            } catch (error) {
+                if (error.name === 'ExitPromptError') {
+                    console.log('\n✖ Command cancelled by user');
+                    process.exit(0);
+                }
+                throw error;
+            }
+        }
+
+        if (!options.format) {
+            // Determine format choices based on provider
+            let formatChoices;
+            let defaultFormat;
+<<<<<<< HEAD
+
+=======
+            
+>>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
+            if (options.provider === 'aws') {
+                formatChoices = [
+                    { name: 'CloudFormation', value: 'cloudformation' },
+                    { name: 'Terraform', value: 'terraform' },
+                    { name: 'Pulumi', value: 'pulumi' }
+                ];
+                defaultFormat = 'cloudformation';
+            } else if (options.provider === 'azure') {
+                formatChoices = [
+                    { name: 'ARM Template', value: 'arm' },
+                    { name: 'Terraform', value: 'terraform' },
+                    { name: 'Pulumi', value: 'pulumi' }
+                ];
+                defaultFormat = 'arm';
+            } else if (options.provider === 'gcp') {
+                formatChoices = [
+                    { name: 'Deployment Manager', value: 'deployment-manager' },
+                    { name: 'Terraform', value: 'terraform' },
+                    { name: 'Pulumi', value: 'pulumi' }
+                ];
+                defaultFormat = 'deployment-manager';
+            }
+
+            try {
+                options.format = await select({
+                    message: 'Select output format:',
+                    choices: formatChoices
+                });
+            } catch (error) {
+                if (error.name === 'ExitPromptError') {
+                    console.log('\n✖ Command cancelled by user');
+                    process.exit(0);
+                }
+                throw error;
+            }
+        }
+
+        // Find the Frigg application
+        const nearestBackendPackageJson = await findNearestBackendPackageJson();
+        if (!nearestBackendPackageJson) {
+            throw new Error('Could not find a Frigg application. Make sure you are in a Frigg project directory.');
+        }
+
+        const backendDir = path.dirname(nearestBackendPackageJson);
+        const backendPackageJsonFile = JSON.parse(fs.readFileSync(nearestBackendPackageJson, 'utf8'));
+        const appName = backendPackageJsonFile.name || 'frigg-app';
+        
+        if (options.verbose) {
+            console.log('Current directory:', process.cwd());
+            console.log('Backend package.json found at:', nearestBackendPackageJson);
+            console.log('Backend directory:', backendDir);
+        }
+
+        // Load app definition
+        const appDefinitionPath = path.join(backendDir, 'index.js');
+        if (!fs.existsSync(appDefinitionPath)) {
+            throw new Error(`App definition not found at ${appDefinitionPath}`);
+        }
+
+        // Analyze the app definition
+        const appModule = require(appDefinitionPath);
+        const appDefinition = appModule.Definition || appModule;
+        const features = analyzeAppFeatures(appDefinition);
+
+        if (options.verbose) {
+            console.log('Detected features:', features);
+        }
+
+        // Generate based on provider and format
+        let template;
+        let fileExtension;
+        let deploymentInstructions;
+
+        if (options.provider === 'aws') {
+            if (options.format === 'cloudformation') {
+                template = await generateCloudFormationTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user',
+                    stackName: options.stackName || 'frigg-deployment-iam'
+                });
+                fileExtension = 'yaml';
+                deploymentInstructions = generateCloudFormationInstructions(options);
+            } else if (options.format === 'terraform') {
+                template = await generateTerraformTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user'
+                });
+                fileExtension = 'tf';
+                deploymentInstructions = generateTerraformInstructions(options);
+            } else if (options.format === 'pulumi') {
+                throw new Error('Pulumi support is not yet implemented');
+            }
+        } else if (options.provider === 'azure') {
+            if (options.format === 'arm') {
+                template = await generateAzureARMTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user'
+                });
+                fileExtension = 'json';
+                deploymentInstructions = generateAzureInstructions(options);
+            } else if (options.format === 'terraform') {
+                template = await generateAzureTerraformTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user'
+                });
+                fileExtension = 'tf';
+                deploymentInstructions = generateTerraformInstructions(options);
+            } else if (options.format === 'pulumi') {
+                throw new Error('Pulumi support for Azure is not yet implemented');
+            }
+        } else if (options.provider === 'gcp') {
+            if (options.format === 'deployment-manager') {
+                template = await generateGCPDeploymentManagerTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user'
+                });
+                fileExtension = 'yaml';
+                deploymentInstructions = generateGCPInstructions(options);
+            } else if (options.format === 'terraform') {
+                template = await generateGCPTerraformTemplate({
+                    appName,
+                    features,
+                    userPrefix: options.user || 'frigg-deployment-user'
+                });
+                fileExtension = 'tf';
+                deploymentInstructions = generateTerraformInstructions(options);
+            } else if (options.format === 'pulumi') {
+                throw new Error('Pulumi support for GCP is not yet implemented');
+            }
+        } else {
+            throw new Error(`Provider ${options.provider} is not yet implemented`);
+        }
+
+        // Ensure output directory exists - smart path detection
+        let outputDir;
+        if (options.output) {
+            // If user specified output, use it as-is
+            outputDir = path.resolve(options.output);
+        } else {
+            // Smart default: put infrastructure in the backend directory we found
+            outputDir = path.join(backendDir, 'infrastructure');
+        }
+<<<<<<< HEAD
+
+        if (options.verbose) {
+            console.log('Output directory will be:', outputDir);
+        }
+
+=======
+        
+        if (options.verbose) {
+            console.log('Output directory will be:', outputDir);
+        }
+        
+>>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+
+        // Write the template
+        const outputFileName = `frigg-deployment-${options.provider}-${options.format}.${fileExtension}`;
+        const outputPath = path.join(outputDir, outputFileName);
+        fs.writeFileSync(outputPath, template);
+
+        // Generate relative path for instructions
+        const relativeOutputDir = path.relative(process.cwd(), outputDir);
+        const relativeOutputPath = path.join(relativeOutputDir, outputFileName);
+
+        console.log(`\n✅ Generated ${options.format} template for ${options.provider}`);
+        console.log(`📄 Template saved to: ${outputPath}`);
+<<<<<<< HEAD
+
+=======
+        
+>>>>>>> 37c4892ee8a686eb7acfcd17c333b0ed73e1f120
+        // Update deployment instructions with actual paths
+        if (deploymentInstructions) {
+            deploymentInstructions = deploymentInstructions
+                .replace(/backend\/infrastructure/g, relativeOutputDir)
+                .replace(/file:\/\/backend\/infrastructure/g, `file://${relativeOutputDir}`);
+        }
+        console.log('\n' + deploymentInstructions);
+
+    } catch (error) {
+        console.error('Error generating deployment credentials:', error.message);
+        if (options.verbose && error.stack) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+
+function analyzeAppFeatures(appDefinition) {
+    const features = {
+        vpc: appDefinition.vpc?.enable === true,
+        kms: appDefinition.encryption?.useDefaultKMSForFieldLevelEncryption === true,
+        ssm: appDefinition.ssm?.enable === true,
+        websockets: appDefinition.websockets?.enable === true,
+        // Add more feature detection as needed
+    };
+
+    return features;
+}
+
+function generateCloudFormationInstructions(options) {
+    const stackName = options.stackName || 'frigg-deployment-iam';
+    return `
+📋 Deployment Instructions (CloudFormation):
+
+1. Deploy the CloudFormation stack:
+   aws cloudformation create-stack \\
+     --stack-name ${stackName} \\
+     --template-body file://${options.output || 'backend/infrastructure'}/frigg-deployment-aws-cloudformation.yaml \\
+     --capabilities CAPABILITY_NAMED_IAM
+
+2. Wait for stack creation to complete:
+   aws cloudformation wait stack-create-complete --stack-name ${stackName}
+
+3. Retrieve the created user ARN:
+   aws cloudformation describe-stacks \\
+     --stack-name ${stackName} \\
+     --query 'Stacks[0].Outputs[?OutputKey==\`UserArn\`].OutputValue' \\
+     --output text
+
+4. Retrieve the access key ID:
+   aws cloudformation describe-stacks \\
+     --stack-name ${stackName} \\
+     --query 'Stacks[0].Outputs[?OutputKey==\`AccessKeyId\`].OutputValue' \\
+     --output text
+
+5. Retrieve the secret access key from Secrets Manager:
+   SECRET_NAME=$(aws cloudformation describe-stacks \\
+     --stack-name ${stackName} \\
+     --query 'Stacks[0].Outputs[?OutputKey==\`SecretName\`].OutputValue' \\
+     --output text)
+   
+   aws secretsmanager get-secret-value \\
+     --secret-id $SECRET_NAME \\
+     --query 'SecretString' \\
+     --output text
+`;
+}
+
+function generateTerraformInstructions(options) {
+    return `
+📋 Deployment Instructions (Terraform):
+
+1. Initialize Terraform:
+   cd ${options.output || 'backend/infrastructure'}
+   terraform init
+
+2. Review the plan:
+   terraform plan
+
+3. Apply the configuration:
+   terraform apply
+
+4. Retrieve the outputs:
+   terraform output -json
+
+5. The access key ID and secret will be displayed in the outputs.
+   Store them securely and use them for your CI/CD pipeline.
+
+⚠️  Security Note: The secret access key is sensitive. Consider using:
+   - terraform output -raw secret_access_key | pbcopy  # Copy to clipboard
+   - Store in your CI/CD secret management system
+   - Delete local state file if not using remote state
+`;
+}
+
+function generateAzureInstructions(options) {
+    return `
+📋 Deployment Instructions (Azure ARM):
+
+Azure ARM template support is coming soon.
+For now, please use Terraform for Azure deployments.
+
+To use Terraform with Azure:
+1. Run: frigg generate --provider azure --format terraform
+2. Follow the Terraform deployment instructions
+`;
+}
+
+function generateGCPInstructions(options) {
+    return `
+📋 Deployment Instructions (GCP Deployment Manager):
+
+GCP Deployment Manager support is coming soon.
+For now, please use Terraform for GCP deployments.
+
+To use Terraform with GCP:
+1. Run: frigg generate --provider gcp --format terraform
+2. Follow the Terraform deployment instructions
+`;
+}
+
+module.exports = generateCommand;