@friggframework/devtools 2.0.0-next.4 → 2.0.0-next.40

package/frigg-cli/__tests__/utils/test-setup.js

@@ -0,0 +1,286 @@
+/**
+ * Global test setup for Frigg CLI tests
+ * This file is executed before each test file
+ */
+
+// Store original environment
+const originalEnv = process.env;
+const originalConsole = { ...console };
+const originalProcess = { ...process };
+
+// Mock console to prevent noisy output during tests
+global.console = {
+  ...console,
+  log: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn()
+};
+
+// Set up test environment variables
+process.env = {
+  ...originalEnv,
+  NODE_ENV: 'test',
+  HOME: '/mock/home',
+  PATH: '/mock/path',
+  CI: 'true'
+};
+
+// Global setup before each test
+beforeEach(() => {
+  // Clear all mocks
+  jest.clearAllMocks();
+  
+  // Reset timers
+  jest.clearAllTimers();
+  
+  // Reset modules
+  jest.resetModules();
+  
+  // Restore original process methods
+  process.exit = originalProcess.exit;
+  process.cwd = originalProcess.cwd;
+  
+  // Mock process.exit to prevent actual exit
+  process.exit = jest.fn();
+  
+  // Mock process.cwd to return predictable path
+  process.cwd = jest.fn().mockReturnValue('/mock/cwd');
+  
+  // Reset console mocks
+  global.console.log.mockClear();
+  global.console.info.mockClear();
+  global.console.warn.mockClear();
+  global.console.error.mockClear();
+  global.console.debug.mockClear();
+});
+
+// Global cleanup after each test
+afterEach(() => {
+  // Restore environment
+  process.env = { ...originalEnv };
+  
+  // Restore process methods
+  process.exit = originalProcess.exit;
+  process.cwd = originalProcess.cwd;
+  
+  // Clear any remaining timers
+  jest.clearAllTimers();
+  
+  // Unmock all modules
+  jest.restoreAllMocks();
+});
+
+// Global teardown after all tests
+afterAll(() => {
+  // Restore original environment completely
+  process.env = originalEnv;
+  
+  // Restore original console
+  global.console = originalConsole;
+  
+  // Restore original process
+  Object.assign(process, originalProcess);
+});
+
+// Custom matchers for CLI testing
+expect.extend({
+  toBeValidExitCode(received) {
+    const validCodes = [0, 1, 2];
+    const pass = validCodes.includes(received);
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received} not to be a valid exit code`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received} to be a valid exit code (0, 1, or 2)`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedError(received, expected) {
+    const errorLogs = global.console.error.mock.calls;
+    const pass = errorLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged error containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged error containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toHaveLoggedInfo(received, expected) {
+    const infoLogs = global.console.info.mock.calls;
+    const pass = infoLogs.some(call => 
+      call.some(arg => 
+        typeof arg === 'string' && arg.includes(expected)
+      )
+    );
+    
+    if (pass) {
+      return {
+        message: () => `expected not to have logged info containing "${expected}"`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected to have logged info containing "${expected}"`,
+        pass: false
+      };
+    }
+  },
+  
+  toBeWithinTimeLimit(received, limit) {
+    const pass = received <= limit;
+    
+    if (pass) {
+      return {
+        message: () => `expected ${received}ms not to be within ${limit}ms`,
+        pass: true
+      };
+    } else {
+      return {
+        message: () => `expected ${received}ms to be within ${limit}ms`,
+        pass: false
+      };
+    }
+  }
+});
+
+// Helper functions available in all tests
+global.TestHelpers = {
+  /**
+   * Create a temporary directory for tests
+   */
+  createTempDir() {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-cli-test-'));
+  },
+  
+  /**
+   * Clean up temporary directory
+   */
+  cleanupTempDir(dirPath) {
+    const fs = require('fs');
+    
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  },
+  
+  /**
+   * Create a mock package.json file
+   */
+  createMockPackageJson(overrides = {}) {
+    return JSON.stringify({
+      name: 'test-package',
+      version: '1.0.0',
+      main: 'index.js',
+      scripts: {
+        test: 'jest',
+        start: 'node index.js'
+      },
+      dependencies: {},
+      devDependencies: {},
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Create a mock frigg.config.json file
+   */
+  createMockFriggConfig(overrides = {}) {
+    return JSON.stringify({
+      stage: 'dev',
+      region: 'us-east-1',
+      profile: 'default',
+      backend: {
+        runtime: 'nodejs18.x',
+        timeout: 30,
+        memory: 128
+      },
+      ...overrides
+    }, null, 2);
+  },
+  
+  /**
+   * Wait for a specific amount of time
+   */
+  async delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  },
+  
+  /**
+   * Generate a random string for test data
+   */
+  randomString(length = 10) {
+    return Math.random().toString(36).substring(2, length + 2);
+  },
+  
+  /**
+   * Simulate file system structure
+   */
+  mockFileSystem(structure) {
+    const fs = require('fs');
+    
+    const originalExistsSync = fs.existsSync;
+    const originalReadFileSync = fs.readFileSync;
+    const originalWriteFileSync = fs.writeFileSync;
+    
+    fs.existsSync = jest.fn((path) => {
+      return structure.hasOwnProperty(path);
+    });
+    
+    fs.readFileSync = jest.fn((path) => {
+      if (structure.hasOwnProperty(path)) {
+        return structure[path];
+      }
+      throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    });
+    
+    fs.writeFileSync = jest.fn((path, data) => {
+      structure[path] = data;
+    });
+    
+    return {
+      restore() {
+        fs.existsSync = originalExistsSync;
+        fs.readFileSync = originalReadFileSync;
+        fs.writeFileSync = originalWriteFileSync;
+      }
+    };
+  }
+};
+
+// Global timeout for all tests
+jest.setTimeout(30000);
+
+// Suppress specific warnings during tests
+const originalWarn = console.warn;
+console.warn = (...args) => {
+  // Suppress specific warnings that are expected during testing
+  const message = args.join(' ');
+  if (message.includes('ExperimentalWarning') || 
+      message.includes('DeprecationWarning')) {
+    return;
+  }
+  originalWarn.apply(console, args);
+};

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

@@ -0,0 +1,54 @@
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+async function buildCommand(options) {
+    console.log('Building the serverless application...');
+    
+    // AWS discovery is now handled directly in serverless-template.js
+    console.log('📦 Packaging serverless application...');
+    const backendPath = path.resolve(process.cwd());
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const serverlessArgs = [
+        'package',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    // Add support for --verbose option
+    if (options.verbose) {
+        serverlessArgs.push('--verbose');
+    }
+
+    console.log('Running command from ', backendPath);
+    console.log('Serverless Command:', command, serverlessArgs.join(' '));
+
+    const result = spawnSync(command, serverlessArgs, {
+        cwd: backendPath,
+        stdio: 'inherit',
+        shell: true,
+        env: {
+            ...process.env,
+            NODE_PATH: path.resolve(backendPath, 'node_modules'),
+        }
+    });
+
+    if (result.status !== 0) {
+        console.error(`Serverless build failed with code ${result.status}`);
+        process.exit(1);
+    }
+
+    // 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}`);
+    //     }
+    // });
+}
+
+module.exports = { buildCommand };

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

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