@friggframework/devtools 2.0.0--canary.461.b5b70c5.0 → 2.0.0--canary.461.4da5172.0

package/frigg-cli/__tests__/unit/commands/build.test.js

@@ -157,6 +157,34 @@ describe('CLI Command: build', () => {
       delete process.env.TEST_VAR;
     });
 
+    it('should set SLS_STAGE environment variable to match stage option', async () => {
+      await buildCommand({ stage: 'qa' });
+
+      const call = spawnSync.mock.calls[0];
+      const options = call[2];
+
+      // Verify SLS_STAGE is set for discovery to use
+      expect(options.env.SLS_STAGE).toBe('qa');
+    });
+
+    it('should set SLS_STAGE for production stage', async () => {
+      await buildCommand({ stage: 'production' });
+
+      const call = spawnSync.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('production');
+    });
+
+    it('should set SLS_STAGE for dev stage', async () => {
+      await buildCommand({ stage: 'dev' });
+
+      const call = spawnSync.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('dev');
+    });
+
     it('should use infrastructure.js as config file', async () => {
       await buildCommand({ stage: 'dev' });
 

package/frigg-cli/__tests__/unit/commands/deploy.test.js

@@ -0,0 +1,281 @@
+/**
+ * Test suite for deploy command
+ *
+ * Tests the serverless deployment functionality including:
+ * - Command execution with spawn
+ * - Stage option handling
+ * - Environment variable filtering and propagation
+ * - SLS_STAGE propagation for resource discovery
+ * - Error handling
+ */
+
+// Mock dependencies BEFORE requiring modules
+jest.mock('child_process', () => ({
+  spawn: jest.fn()
+}));
+
+jest.mock('fs', () => ({
+  existsSync: jest.fn()
+}));
+
+// Require after mocks
+const { spawn } = require('child_process');
+const fs = require('fs');
+const { deployCommand } = require('../../../deploy-command');
+
+describe('CLI Command: deploy', () => {
+  let consoleLogSpy;
+  let consoleWarnSpy;
+  let consoleErrorSpy;
+  let mockChildProcess;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock console methods
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+    // Mock child process
+    mockChildProcess = {
+      on: jest.fn()
+    };
+
+    // Mock successful spawn by default
+    spawn.mockReturnValue(mockChildProcess);
+
+    // Mock fs.existsSync to return false (no app definition)
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('Success Cases', () => {
+    it('should spawn serverless with default stage', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        ['deploy', '--config', 'infrastructure.js', '--stage', 'dev'],
+        expect.objectContaining({
+          cwd: expect.any(String),
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should spawn serverless with production stage', async () => {
+      await deployCommand({ stage: 'production' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--stage', 'production']),
+        expect.any(Object)
+      );
+    });
+
+    it('should spawn serverless with qa stage', async () => {
+      await deployCommand({ stage: 'qa' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--stage', 'qa']),
+        expect.any(Object)
+      );
+    });
+
+    it('should use process.cwd() as working directory', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.cwd).toBe(process.cwd());
+    });
+
+    it('should use stdio inherit for output streaming', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.stdio).toBe('inherit');
+    });
+
+    it('should set SLS_STAGE environment variable to match stage option', async () => {
+      await deployCommand({ stage: 'qa' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      // Verify SLS_STAGE is set for discovery to use
+      expect(options.env.SLS_STAGE).toBe('qa');
+    });
+
+    it('should set SLS_STAGE for production stage', async () => {
+      await deployCommand({ stage: 'production' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('production');
+    });
+
+    it('should set SLS_STAGE for dev stage', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.SLS_STAGE).toBe('dev');
+    });
+
+    it('should use infrastructure.js as config file', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'osls',
+        expect.arrayContaining(['--config', 'infrastructure.js']),
+        expect.any(Object)
+      );
+    });
+
+    it('should log deployment start messages', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Deploying the serverless application...');
+      expect(consoleLogSpy).toHaveBeenCalledWith('🚀 Deploying serverless application...');
+    });
+
+    it('should include essential system environment variables', async () => {
+      process.env.PATH = '/usr/bin';
+      process.env.HOME = '/home/user';
+      process.env.USER = 'testuser';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.PATH).toBe('/usr/bin');
+      expect(options.env.HOME).toBe('/home/user');
+      expect(options.env.USER).toBe('testuser');
+    });
+
+    it('should include AWS environment variables', async () => {
+      process.env.AWS_REGION = 'us-east-1';
+      process.env.AWS_PROFILE = 'test-profile';
+      process.env.AWS_ACCESS_KEY_ID = 'test-key';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      expect(options.env.AWS_REGION).toBe('us-east-1');
+      expect(options.env.AWS_PROFILE).toBe('test-profile');
+      expect(options.env.AWS_ACCESS_KEY_ID).toBe('test-key');
+
+      delete process.env.AWS_REGION;
+      delete process.env.AWS_PROFILE;
+      delete process.env.AWS_ACCESS_KEY_ID;
+    });
+
+    it('should register error handler', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(mockChildProcess.on).toHaveBeenCalledWith('error', expect.any(Function));
+    });
+
+    it('should register close handler', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      expect(mockChildProcess.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+  });
+
+  describe('Environment Variable Filtering', () => {
+    it('should filter environment variables when app definition exists', async () => {
+      // Mock app definition with environment config
+      fs.existsSync.mockReturnValue(true);
+      jest.mock(
+        process.cwd() + '/index.js',
+        () => ({
+          Definition: {
+            environment: {
+              DATABASE_URL: true,
+              API_KEY: true
+            }
+          }
+        }),
+        { virtual: true }
+      );
+
+      process.env.DATABASE_URL = 'postgres://localhost';
+      process.env.API_KEY = 'test-key';
+      process.env.RANDOM_VAR = 'should-not-be-included';
+
+      await deployCommand({ stage: 'dev' });
+
+      const call = spawn.mock.calls[0];
+      const options = call[2];
+
+      // Should include app-defined variables
+      expect(options.env.DATABASE_URL).toBe('postgres://localhost');
+      expect(options.env.API_KEY).toBe('test-key');
+
+      // Should NOT include non-app-defined variables (except system/AWS)
+      expect(options.env.RANDOM_VAR).toBeUndefined();
+
+      delete process.env.DATABASE_URL;
+      delete process.env.API_KEY;
+      delete process.env.RANDOM_VAR;
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should log error when spawn fails', async () => {
+      const testError = new Error('Spawn failed');
+
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate error event
+      const errorHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'error'
+      )[1];
+      errorHandler(testError);
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing command: Spawn failed');
+    });
+
+    it('should log when child process exits with non-zero code', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate close event with error code
+      const closeHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'close'
+      )[1];
+      closeHandler(1);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('Child process exited with code 1');
+    });
+
+    it('should NOT log when child process exits with zero code', async () => {
+      await deployCommand({ stage: 'dev' });
+
+      // Simulate close event with success code
+      const closeHandler = mockChildProcess.on.mock.calls.find(
+        call => call[0] === 'close'
+      )[1];
+      closeHandler(0);
+
+      // Should not log exit message for success
+      expect(consoleLogSpy).not.toHaveBeenCalledWith('Child process exited with code 0');
+    });
+  });
+});

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

@@ -43,6 +43,7 @@ async function buildCommand(options) {
         env: {
             ...process.env,
             NODE_PATH: path.resolve(backendPath, 'node_modules'),
+            SLS_STAGE: options.stage, // Set stage for resource discovery
         }
     });
 

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

@@ -149,7 +149,10 @@ function executeServerlessDeployment(environment, options) {
     const childProcess = spawn(COMMANDS.SERVERLESS, serverlessArgs, {
         cwd: path.resolve(process.cwd()),
         stdio: 'inherit',
-        env: environment,
+        env: {
+            ...environment,
+            SLS_STAGE: options.stage, // Set stage for resource discovery
+        },
     });
 
     childProcess.on('error', (error) => {

package/infrastructure/domains/shared/resource-discovery.test.js

@@ -392,6 +392,29 @@ describe('Resource Discovery', () => {
             );
         });
 
+        it('should read stage from SLS_STAGE environment variable for CLI integration', async () => {
+            // This test documents the contract between frigg CLI and discovery
+            // The CLI sets SLS_STAGE environment variable when user passes --stage flag
+            process.env.SLS_STAGE = 'qa';
+
+            const appDefinition = {
+                name: 'quo-integrations',
+                vpc: { enable: true },
+            };
+
+            await gatherDiscoveredResources(appDefinition);
+
+            // Verify stage is read from SLS_STAGE
+            expect(mockVpcDiscovery.discover).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    serviceName: 'quo-integrations',
+                    stage: 'qa',
+                })
+            );
+
+            delete process.env.SLS_STAGE;
+        });
+
         it('should include secrets in SSM discovery by default', async () => {
             const appDefinition = {
                 ssm: { enable: true },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.461.b5b70c5.0",
+  "version": "2.0.0--canary.461.4da5172.0",
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.835.0",
     "@aws-sdk/client-kms": "^3.835.0",
@@ -11,8 +11,8 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/schemas": "2.0.0--canary.461.b5b70c5.0",
-    "@friggframework/test": "2.0.0--canary.461.b5b70c5.0",
+    "@friggframework/schemas": "2.0.0--canary.461.4da5172.0",
+    "@friggframework/test": "2.0.0--canary.461.4da5172.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -34,8 +34,8 @@
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.461.b5b70c5.0",
-    "@friggframework/prettier-config": "2.0.0--canary.461.b5b70c5.0",
+    "@friggframework/eslint-config": "2.0.0--canary.461.4da5172.0",
+    "@friggframework/prettier-config": "2.0.0--canary.461.4da5172.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b5b70c50ff3e8efed4e1b8b2431cccd7c049b366"
+  "gitHead": "4da5172ec0648a071c48a497c1db728a55e0ab8d"
 }