@friggframework/devtools 2.0.0-next.61 → 2.0.0-next.62

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

@@ -1,444 +0,0 @@
-/**
- * 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

@@ -1,78 +0,0 @@
-/**
- * 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

@@ -1,173 +0,0 @@
-/**
- * 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');
-        });
-    });
-});
-