@friggframework/devtools 2.0.0-next.5 → 2.0.0-next.50

package/infrastructure/domains/shared/utilities/prisma-layer-manager.test.js

@@ -0,0 +1,444 @@
+/**
+ * Tests for Prisma Layer Manager
+ * 
+ * Tests Prisma Lambda Layer existence checking and building
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { ensurePrismaLayerExists } = require('./prisma-layer-manager');
+
+// Mock fs and buildPrismaLayer
+jest.mock('fs');
+jest.mock('../../../scripts/build-prisma-layer', () => ({
+    buildPrismaLayer: jest.fn(),
+}));
+
+const { buildPrismaLayer } = require('../../../scripts/build-prisma-layer');
+
+// Helper to mock fs methods for different scenarios
+const mockFs = {
+    completedBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return true;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    incompleteBuild: () => {
+        fs.existsSync = jest.fn((path) => {
+            if (path.endsWith('.build-complete')) return false;
+            if (path.endsWith('layers/prisma')) return true;
+            return false;
+        });
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+    noBuild: () => {
+        fs.existsSync = jest.fn().mockReturnValue(false);
+        fs.writeFileSync = jest.fn();
+        fs.rmSync = jest.fn();
+    },
+};
+
+describe('Prisma Layer Manager', () => {
+    let originalCwd;
+
+    beforeEach(() => {
+        originalCwd = process.cwd;
+        process.cwd = jest.fn().mockReturnValue('/project');
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        process.cwd = originalCwd;
+    });
+
+    describe('ensurePrismaLayerExists()', () => {
+        it('should skip build if layer already exists', async () => {
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
+
+            await ensurePrismaLayerExists();
+
+            expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
+            expect(buildPrismaLayer).not.toHaveBeenCalled();
+        });
+
+        it('should build layer if it does not exist', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            await ensurePrismaLayerExists();
+
+            expect(buildPrismaLayer).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass database config to buildPrismaLayer', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            const databaseConfig = {
+                postgres: { enable: true },
+            };
+
+            await ensurePrismaLayerExists(databaseConfig);
+
+            expect(buildPrismaLayer).toHaveBeenCalledWith(databaseConfig);
+        });
+
+        it('should handle build errors and rethrow', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+            await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+        });
+
+        it('should default to empty database config', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+
+            await ensurePrismaLayerExists();
+
+            expect(buildPrismaLayer).toHaveBeenCalledWith({});
+        });
+
+        it('should use correct layer path relative to project root', async () => {
+            process.cwd = jest.fn().mockReturnValue('/custom/project/path');
+            fs.existsSync = jest.fn((path) => {
+                // Completion marker exists
+                if (path.endsWith('.build-complete')) return true;
+                return false;
+            });
+
+            await ensurePrismaLayerExists();
+
+            expect(fs.existsSync).toHaveBeenCalledWith('/custom/project/path/layers/prisma/.build-complete');
+        });
+
+        it('should log success when layer already exists', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(true);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await ensurePrismaLayerExists();
+
+            // console.log is called with 2 args: message + path
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('already exists'),
+                expect.any(String)
+            );
+
+            consoleSpy.mockRestore();
+        });
+
+        it('should log build progress when building layer', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockResolvedValue();
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await ensurePrismaLayerExists();
+
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('building automatically')
+            );
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('built successfully')
+            );
+
+            consoleSpy.mockRestore();
+        });
+
+        it('should log error message on build failure', async () => {
+            fs.existsSync = jest.fn().mockReturnValue(false);
+            buildPrismaLayer.mockRejectedValue(new Error('Build error'));
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+            await expect(ensurePrismaLayerExists()).rejects.toThrow();
+
+            // console.error is called with 2 args: message + error
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to build'),
+                expect.any(String)
+            );
+
+            consoleErrorSpy.mockRestore();
+        });
+
+        describe('Concurrent Build Protection', () => {
+            it('should skip build if completion marker exists (TDD)', async () => {
+                mockFs.completedBuild();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.existsSync).toHaveBeenCalledWith('/project/layers/prisma/.build-complete');
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+            });
+
+            it('should wait for active build process to complete (TDD)', async () => {
+                jest.useFakeTimers();
+
+                // Mock active lock file with running process
+                const activePid = 12345;
+                let completionMarkerExists = false;
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue(activePid.toString());
+                fs.writeFileSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to simulate running process, then completion
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 seconds, build completes
+                        completionMarkerExists = true;
+                    }
+                    return true; // Process is running
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
+
+                await promise;
+
+                // Should not rebuild (waited for concurrent build)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                process.kill = originalKill;
+                jest.useRealTimers();
+            });
+
+            it('should clean stale lock file if process not running (TDD)', async () => {
+                // Mock stale lock file (process not running)
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue('99999');
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to throw (process not running)
+                const originalKill = process.kill;
+                process.kill = jest.fn(() => {
+                    throw new Error('ESRCH');
+                });
+
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should remove stale lock
+                expect(fs.rmSync).toHaveBeenCalledWith('/project/layers/prisma/.build-lock', { force: true });
+                // Should proceed with build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                process.kill = originalKill;
+            });
+
+            it('should create and remove lock file during build (TDD)', async () => {
+                // Mock to simulate successful build flow
+                fs.existsSync = jest.fn((path) => {
+                    // Completion marker doesn't exist initially
+                    if (path.endsWith('.build-complete')) return false;
+                    // Lock file exists in finally block (after writeFileSync)
+                    if (path.endsWith('.build-lock')) return true;
+                    // Directory doesn't exist initially
+                    if (path.endsWith('layers/prisma')) return false;
+                    return false;
+                });
+                fs.writeFileSync = jest.fn();
+                fs.mkdirSync = jest.fn();
+                fs.rmSync = jest.fn();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                // Should create directory for lock file
+                expect(fs.mkdirSync).toHaveBeenCalledWith('/project/layers/prisma', { recursive: true });
+
+                // Should create lock file with PID
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    expect.any(String)
+                );
+
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
+            it('should remove lock file even if build fails (TDD)', async () => {
+                mockFs.noBuild();
+                fs.mkdirSync = jest.fn();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+                // After failure, directory exists
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('.build-lock')) return true;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                // Should remove lock file in finally block
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-lock',
+                    { force: true }
+                );
+            });
+
+            it('should wait and rebuild if directory exists without completion marker (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should NOT manually clean (buildPrismaLayer handles this)
+                expect(fs.rmSync).not.toHaveBeenCalled();
+                // Should rebuild
+                expect(buildPrismaLayer).toHaveBeenCalled();
+                // Should create completion marker
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+
+                jest.useRealTimers();
+            });
+
+            it('should create completion marker after successful build (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                await ensurePrismaLayerExists();
+
+                expect(fs.writeFileSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma/.build-complete',
+                    expect.any(String)
+                );
+            });
+
+            it('should clean up partial build on failure (TDD)', async () => {
+                mockFs.noBuild();
+                buildPrismaLayer.mockRejectedValue(new Error('Build failed'));
+
+                // After build attempt fails, directory exists
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return false;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+
+                await expect(ensurePrismaLayerExists()).rejects.toThrow('Build failed');
+
+                // Should clean up after failure
+                expect(fs.rmSync).toHaveBeenCalledWith(
+                    '/project/layers/prisma',
+                    { recursive: true, force: true }
+                );
+            });
+
+            it('should wait for potential concurrent build before rebuilding (TDD)', async () => {
+                jest.useFakeTimers();
+                mockFs.incompleteBuild();
+                buildPrismaLayer.mockResolvedValue();
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait
+                jest.advanceTimersByTime(1000);
+
+                await promise;
+
+                // Should wait before rebuilding
+                // Should still attempt to build
+                expect(buildPrismaLayer).toHaveBeenCalled();
+
+                jest.useRealTimers();
+            });
+
+            it('should detect when concurrent process completes during wait (TDD)', async () => {
+                jest.useFakeTimers();
+
+                // Simulate lock file existing with completion happening during wait
+                let completionMarkerExists = false;
+                let lockFileExists = true;
+                fs.existsSync = jest.fn((path) => {
+                    if (path.endsWith('.build-complete')) return completionMarkerExists;
+                    if (path.endsWith('.build-lock')) return lockFileExists;
+                    if (path.endsWith('layers/prisma')) return true;
+                    return false;
+                });
+                fs.readFileSync = jest.fn().mockReturnValue('12345');
+                fs.writeFileSync = jest.fn();
+                fs.rmSync = jest.fn();
+
+                // Mock process.kill to simulate active process
+                let killCallCount = 0;
+                const originalKill = process.kill;
+                process.kill = jest.fn((pid, signal) => {
+                    killCallCount++;
+                    if (killCallCount >= 3) {
+                        // After 3 checks, build completes
+                        completionMarkerExists = true;
+                        lockFileExists = false;
+                    }
+                    return true; // Process is running
+                });
+
+                const promise = ensurePrismaLayerExists();
+
+                // Fast-forward through the wait loop
+                for (let i = 0; i < 5; i++) {
+                    jest.advanceTimersByTime(1000);
+                    await Promise.resolve();
+                }
+
+                await promise;
+
+                // Should not rebuild (concurrent process completed)
+                expect(buildPrismaLayer).not.toHaveBeenCalled();
+
+                process.kill = originalKill;
+                jest.useRealTimers();
+            });
+        });
+    });
+});
+

package/infrastructure/domains/shared/validation/env-validator.js

@@ -0,0 +1,78 @@
+/**
+ * Environment variable validator for Frigg applications
+ * Validates that required environment variables are present based on appDefinition
+ */
+
+/**
+ * Validate environment variables against appDefinition
+ * @param {Object} AppDefinition - Application definition with environment config
+ * @returns {Object} Validation results with valid, missing, and warnings arrays
+ */
+const validateEnvironmentVariables = (AppDefinition) => {
+    const results = {
+        valid: [],
+        missing: [],
+        warnings: [],
+    };
+
+    if (!AppDefinition.environment) {
+        return results;
+    }
+
+    console.log('🔍 Validating environment variables...');
+
+    for (const [key, value] of Object.entries(AppDefinition.environment)) {
+        if (value === true) {
+            // Use 'in' operator to check if key exists (undefined = missing, empty string = present)
+            if (key in process.env) {
+                results.valid.push(key);
+            } else {
+                results.missing.push(key);
+            }
+        }
+    }
+
+    // Special handling for certain variables
+    if (results.missing.includes('NODE_ENV')) {
+        results.warnings.push('NODE_ENV not set, defaulting to "production"');
+        // Remove from missing since it has a default
+        results.missing = results.missing.filter((v) => v !== 'NODE_ENV');
+    }
+
+    // Report results
+    if (results.valid.length > 0) {
+        console.log(
+            `   ✅ Valid: ${results.valid.length} environment variables found`
+        );
+    }
+
+    if (results.missing.length > 0) {
+        console.log(`   ⚠️  Missing: ${results.missing.join(', ')}`);
+        results.warnings.push(
+            `Missing ${results.missing.length} environment variables. These should be set in your CI/CD environment or .env file`
+        );
+    }
+
+    if (results.warnings.length > 0) {
+        results.warnings.forEach((warning) => {
+            console.log(`   ⚠️  ${warning}`);
+        });
+    }
+
+    return results;
+};
+
+/**
+ * Check if all required environment variables are present
+ * @param {Object} AppDefinition - Application definition
+ * @returns {boolean} True if all required variables are present
+ */
+const hasAllRequiredEnvVars = (AppDefinition) => {
+    const results = validateEnvironmentVariables(AppDefinition);
+    return results.missing.length === 0;
+};
+
+module.exports = {
+    validateEnvironmentVariables,
+    hasAllRequiredEnvVars,
+};

package/infrastructure/domains/shared/validation/env-validator.test.js

@@ -0,0 +1,173 @@
+/**
+ * Tests for Environment Variable Validator
+ * 
+ * Tests validation of required environment variables
+ */
+
+const { validateEnvironmentVariables } = require('./env-validator');
+
+describe('Environment Validator', () => {
+    let originalEnv;
+
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+        // Clear test-related env vars
+        delete process.env.TEST_VAR_1;
+        delete process.env.TEST_VAR_2;
+        delete process.env.NODE_ENV;
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('validateEnvironmentVariables()', () => {
+        it('should return empty results for app definition without environment', () => {
+            const appDefinition = {};
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual([]);
+            expect(result.missing).toEqual([]);
+            expect(result.warnings).toEqual([]);
+        });
+
+        it('should validate present environment variables', () => {
+            process.env.TEST_VAR_1 = 'value1';
+            process.env.TEST_VAR_2 = 'value2';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1', 'TEST_VAR_2']);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should detect missing environment variables', () => {
+            process.env.TEST_VAR_1 = 'value1';
+            // TEST_VAR_2 not set
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1']);
+            expect(result.missing).toEqual(['TEST_VAR_2']);
+        });
+
+        it('should only validate variables with value true', () => {
+            process.env.TEST_VAR_1 = 'value1';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR_1: true,
+                    TEST_VAR_2: false,
+                    TEST_VAR_3: 'string-value',
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['TEST_VAR_1']);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should handle NODE_ENV specially with warning', () => {
+            // NODE_ENV not set
+
+            const appDefinition = {
+                environment: {
+                    NODE_ENV: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.missing).not.toContain('NODE_ENV');
+            expect(result.warnings).toContain('NODE_ENV not set, defaulting to "production"');
+        });
+
+        it('should not warn about NODE_ENV if it is set', () => {
+            process.env.NODE_ENV = 'development';
+
+            const appDefinition = {
+                environment: {
+                    NODE_ENV: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toContain('NODE_ENV');
+            expect(result.warnings).not.toContain('NODE_ENV not set, defaulting to "production"');
+        });
+
+        it('should warn about missing variables', () => {
+            const appDefinition = {
+                environment: {
+                    MISSING_VAR_1: true,
+                    MISSING_VAR_2: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.missing).toEqual(['MISSING_VAR_1', 'MISSING_VAR_2']);
+            expect(result.warnings.length).toBeGreaterThan(0);
+        });
+
+        it('should handle mixed valid and missing variables', () => {
+            process.env.VALID_VAR = 'value';
+
+            const appDefinition = {
+                environment: {
+                    VALID_VAR: true,
+                    MISSING_VAR: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual(['VALID_VAR']);
+            expect(result.missing).toEqual(['MISSING_VAR']);
+        });
+
+        it('should handle empty environment object', () => {
+            const appDefinition = {
+                environment: {},
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            expect(result.valid).toEqual([]);
+            expect(result.missing).toEqual([]);
+        });
+
+        it('should handle environment variables with empty string values', () => {
+            process.env.TEST_VAR = '';
+
+            const appDefinition = {
+                environment: {
+                    TEST_VAR: true,
+                },
+            };
+
+            const result = validateEnvironmentVariables(appDefinition);
+
+            // Empty string is still considered "present"
+            expect(result.valid).toContain('TEST_VAR');
+        });
+    });
+});
+