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

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

@@ -9,6 +9,8 @@ function startCommand(options) {
     console.log('Starting backend and optional frontend...');
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = 1;
+    // Skip AWS discovery for local development
+    process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
     const backendPath = path.resolve(process.cwd());
     console.log(`Starting backend in ${backendPath}...`);
     const infrastructurePath = 'infrastructure.js';
@@ -34,6 +36,10 @@ function startCommand(options) {
     const childProcess = spawn(command, args, {
         cwd: backendPath,
         stdio: 'inherit',
+        env: {
+            ...process.env,
+            FRIGG_SKIP_AWS_DISCOVERY: 'true',
+        },
     });
 
     childProcess.on('error', (error) => {

package/frigg-cli/start-command/start-command.test.js

@@ -0,0 +1,155 @@
+/**
+ * Test suite for the frigg start command
+ *
+ * These tests ensure that the start command properly:
+ * 1. Sets FRIGG_SKIP_AWS_DISCOVERY=true in the parent process to skip AWS API calls
+ * 2. Suppresses AWS SDK maintenance mode warnings
+ * 3. Spawns serverless with correct configuration
+ *
+ * This fixes the issue where frigg start would attempt AWS discovery during local development,
+ * causing unnecessary AWS API calls and potential failures when AWS credentials aren't available.
+ */
+
+const { spawn } = require('node:child_process');
+const { startCommand } = require('./index');
+
+// Mock the spawn function
+jest.mock('node:child_process', () => ({
+    spawn: jest.fn(),
+}));
+
+describe('startCommand', () => {
+    let mockChildProcess;
+
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks();
+
+        // Clear environment variables
+        delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
+        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
+
+        // Create a mock child process
+        mockChildProcess = {
+            on: jest.fn(),
+            stdout: { on: jest.fn() },
+            stderr: { on: jest.fn() },
+        };
+
+        spawn.mockReturnValue(mockChildProcess);
+    });
+
+    afterEach(() => {
+        // Clean up environment
+        delete process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE;
+        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
+    });
+
+    it('should set FRIGG_SKIP_AWS_DISCOVERY to true in the parent process', () => {
+        const options = { stage: 'dev' };
+
+        startCommand(options);
+
+        // Verify the environment variable is set in the parent process
+        expect(process.env.FRIGG_SKIP_AWS_DISCOVERY).toBe('true');
+    });
+
+    it('should set AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE to suppress warnings', () => {
+        const options = { stage: 'dev' };
+
+        startCommand(options);
+
+        expect(process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE).toBe('1');
+    });
+
+    it('should spawn serverless with correct arguments', () => {
+        const options = { stage: 'prod' };
+
+        startCommand(options);
+
+        expect(spawn).toHaveBeenCalledWith(
+            'serverless',
+            ['offline', '--config', 'infrastructure.js', '--stage', 'prod'],
+            expect.objectContaining({
+                cwd: expect.any(String),
+                stdio: 'inherit',
+                env: expect.objectContaining({
+                    FRIGG_SKIP_AWS_DISCOVERY: 'true',
+                }),
+            })
+        );
+    });
+
+    it('should include verbose flag when verbose option is enabled', () => {
+        const options = { stage: 'dev', verbose: true };
+
+        startCommand(options);
+
+        expect(spawn).toHaveBeenCalledWith(
+            'serverless',
+            ['offline', '--config', 'infrastructure.js', '--stage', 'dev', '--verbose'],
+            expect.any(Object)
+        );
+    });
+
+    it('should pass FRIGG_SKIP_AWS_DISCOVERY in spawn environment', () => {
+        const options = { stage: 'dev' };
+
+        startCommand(options);
+
+        const spawnCall = spawn.mock.calls[0];
+        const spawnOptions = spawnCall[2];
+
+        expect(spawnOptions.env).toHaveProperty('FRIGG_SKIP_AWS_DISCOVERY', 'true');
+    });
+
+    it('should handle child process errors', () => {
+        const options = { stage: 'dev' };
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+        startCommand(options);
+
+        // Simulate an error
+        const errorCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'error')[1];
+        const testError = new Error('Test error');
+        errorCallback(testError);
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing command: Test error');
+
+        consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle child process exit with non-zero code', () => {
+        const options = { stage: 'dev' };
+        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+        startCommand(options);
+
+        // Simulate exit with error code
+        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
+        closeCallback(1);
+
+        expect(consoleLogSpy).toHaveBeenCalledWith('Child process exited with code 1');
+
+        consoleLogSpy.mockRestore();
+    });
+
+    it('should not log on successful exit', () => {
+        const options = { stage: 'dev' };
+        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+        startCommand(options);
+
+        // Clear the spy calls from startCommand execution
+        consoleLogSpy.mockClear();
+
+        // Simulate successful exit
+        const closeCallback = mockChildProcess.on.mock.calls.find(call => call[0] === 'close')[1];
+        closeCallback(0);
+
+        // Should not log anything for successful exit
+        expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining('exited'));
+
+        consoleLogSpy.mockRestore();
+    });
+});

package/infrastructure/serverless-template.js

@@ -2,10 +2,19 @@ const path = require('path');
 const fs = require('fs');
 const { AWSDiscovery } = require('./aws-discovery');
 
-const shouldRunDiscovery = (AppDefinition) =>
-    AppDefinition.vpc?.enable === true ||
-    AppDefinition.encryption?.fieldLevelEncryptionMethod === 'kms' ||
-    AppDefinition.ssm?.enable === true;
+const shouldRunDiscovery = (AppDefinition) => {
+    console.log('⚙️  Checking FRIGG_SKIP_AWS_DISCOVERY:', process.env.FRIGG_SKIP_AWS_DISCOVERY);
+    if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+        console.log('⚙️  Skipping AWS discovery because FRIGG_SKIP_AWS_DISCOVERY is set.');
+        return false;
+    }
+
+    return (
+        AppDefinition.vpc?.enable === true ||
+        AppDefinition.encryption?.fieldLevelEncryptionMethod === 'kms' ||
+        AppDefinition.ssm?.enable === true
+    );
+};
 
 const getAppEnvironmentVars = (AppDefinition) => {
     const envVars = {};
@@ -649,6 +658,12 @@ const applyKmsConfiguration = (definition, AppDefinition, discoveredResources) =
         return;
     }
 
+    // Skip KMS configuration for local development when AWS discovery is disabled
+    if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+        console.log('⚙️  Skipping KMS configuration for local development (FRIGG_SKIP_AWS_DISCOVERY is set)');
+        return;
+    }
+
     if (discoveredResources.defaultKmsKeyId) {
         console.log(`Using existing KMS key: ${discoveredResources.defaultKmsKeyId}`);
         definition.resources.Resources.FriggKMSKeyAlias = {
@@ -846,6 +861,12 @@ const configureVpc = (definition, AppDefinition, discoveredResources) => {
         return;
     }
 
+    // Skip VPC configuration for local development when AWS discovery is disabled
+    if (process.env.FRIGG_SKIP_AWS_DISCOVERY === 'true') {
+        console.log('⚙️  Skipping VPC configuration for local development (FRIGG_SKIP_AWS_DISCOVERY is set)');
+        return;
+    }
+
     definition.provider.iamRoleStatements.push({
         Effect: 'Allow',
         Action: [

package/infrastructure/serverless-template.test.js

@@ -55,6 +55,7 @@ describe('composeServerlessDefinition', () => {
         jest.restoreAllMocks();
         // Restore env
         delete process.env.AWS_REGION;
+        delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
         process.argv = ['node', 'test'];
     });
 
@@ -86,6 +87,50 @@ describe('composeServerlessDefinition', () => {
 
             expect(AWSDiscovery).toHaveBeenCalledTimes(1);
         });
+
+        it('should skip AWS discovery when FRIGG_SKIP_AWS_DISCOVERY is set to true', async () => {
+            AWSDiscovery.mockClear();
+            process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
+
+            const appDefinition = {
+                integrations: [],
+                vpc: { enable: true },
+                encryption: { fieldLevelEncryptionMethod: 'kms' },
+                ssm: { enable: true },
+            };
+
+            await composeServerlessDefinition(appDefinition);
+
+            expect(AWSDiscovery).not.toHaveBeenCalled();
+        });
+
+        it('should run AWS discovery when FRIGG_SKIP_AWS_DISCOVERY is not set', async () => {
+            AWSDiscovery.mockClear();
+            delete process.env.FRIGG_SKIP_AWS_DISCOVERY;
+
+            const appDefinition = {
+                integrations: [],
+                vpc: { enable: true },
+            };
+
+            await composeServerlessDefinition(appDefinition);
+
+            expect(AWSDiscovery).toHaveBeenCalledTimes(1);
+        });
+
+        it('should skip VPC configuration when FRIGG_SKIP_AWS_DISCOVERY is true', async () => {
+            process.env.FRIGG_SKIP_AWS_DISCOVERY = 'true';
+
+            const appDefinition = {
+                integrations: [],
+                vpc: { enable: true, management: 'discover' },
+            };
+
+            const result = await composeServerlessDefinition(appDefinition);
+
+            // VPC configuration should not be present when skipped
+            expect(result.provider.vpc).toBeUndefined();
+        });
     });
 
     describe('Basic Configuration', () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.40",
+  "version": "2.0.0-next.41",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -9,8 +9,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0-next.40",
-    "@friggframework/test": "2.0.0-next.40",
+    "@friggframework/schemas": "2.0.0-next.41",
+    "@friggframework/test": "2.0.0-next.41",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -32,8 +32,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.40",
-    "@friggframework/prettier-config": "2.0.0-next.40",
+    "@friggframework/eslint-config": "2.0.0-next.41",
+    "@friggframework/prettier-config": "2.0.0-next.41",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -68,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "088c50c6e1e37a6d42be05af49349b70ae94ee31"
+  "gitHead": "a5c413164c1b492a228689851d037706f7f869af"
 }