@friggframework/devtools 2.0.0-next.45 → 2.0.0-next.46

package/frigg-cli/__tests__/unit/utils/database-validator.test.js

@@ -1,366 +0,0 @@
-// Mock dependencies BEFORE importing database-validator
-jest.mock('@friggframework/core/database/config', () => ({
-    getDatabaseType: jest.fn()
-}));
-
-jest.mock('@friggframework/core/database/prisma', () => ({
-    connectPrisma: jest.fn(),
-    disconnectPrisma: jest.fn()
-}));
-
-const {
-    validateDatabaseUrl,
-    getDatabaseType,
-    testDatabaseConnection,
-    checkPrismaClientGenerated
-} = require('../../../utils/database-validator');
-const {
-    createMockPrismaClient,
-    createPrismaError,
-    PrismaErrors
-} = require('../../utils/prisma-mock');
-
-const { getDatabaseType: getDatabaseTypeFromCore } = require('@friggframework/core/database/config');
-const { connectPrisma, disconnectPrisma } = require('@friggframework/core/database/prisma');
-
-describe('Database Validator Utility', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        delete process.env.DATABASE_URL;
-    });
-
-    afterEach(() => {
-        delete process.env.DATABASE_URL;
-    });
-
-    describe('validateDatabaseUrl()', () => {
-        it('should return valid when DATABASE_URL exists with value', () => {
-            process.env.DATABASE_URL = 'mongodb://localhost:27017/test';
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(true);
-            expect(result.url).toBe('mongodb://localhost:27017/test');
-            expect(result.error).toBeUndefined();
-        });
-
-        it('should return error when DATABASE_URL is undefined', () => {
-            delete process.env.DATABASE_URL;
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(false);
-            expect(result.error).toBe('DATABASE_URL environment variable not found');
-            expect(result.url).toBeUndefined();
-        });
-
-        it('should return error when DATABASE_URL is empty string', () => {
-            // Set to empty string explicitly
-            process.env.DATABASE_URL = '';
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(false);
-            // Node.js treats empty string env vars as undefined in some contexts
-            expect(result.error).toMatch(/DATABASE_URL environment variable (is empty|not found)/);
-        });
-
-        it('should return error when DATABASE_URL contains only whitespace', () => {
-            process.env.DATABASE_URL = '   ';
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(false);
-            expect(result.error).toBe('DATABASE_URL environment variable is empty');
-        });
-
-        it('should accept valid MongoDB connection strings', () => {
-            process.env.DATABASE_URL = 'mongodb://localhost:27017/frigg?replicaSet=rs0';
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(true);
-            expect(result.url).toContain('mongodb://');
-        });
-
-        it('should accept valid PostgreSQL connection strings', () => {
-            process.env.DATABASE_URL = 'postgresql://postgres:pass@localhost:5432/frigg';
-
-            const result = validateDatabaseUrl();
-
-            expect(result.valid).toBe(true);
-            expect(result.url).toContain('postgresql://');
-        });
-    });
-
-    describe('getDatabaseType()', () => {
-        it('should return postgresql when core returns postgresql', () => {
-            getDatabaseTypeFromCore.mockReturnValue('postgresql');
-
-            const result = getDatabaseType();
-
-            expect(result.dbType).toBe('postgresql');
-            expect(result.error).toBeUndefined();
-            expect(getDatabaseTypeFromCore).toHaveBeenCalled();
-        });
-
-        it('should return mongodb when core returns mongodb', () => {
-            getDatabaseTypeFromCore.mockReturnValue('mongodb');
-
-            const result = getDatabaseType();
-
-            expect(result.dbType).toBe('mongodb');
-            expect(result.error).toBeUndefined();
-        });
-
-        it('should return error when core throws error', () => {
-            getDatabaseTypeFromCore.mockImplementation(() => {
-                throw new Error('[Frigg] Database not configured');
-            });
-
-            const result = getDatabaseType();
-
-            expect(result.dbType).toBeUndefined();
-            expect(result.error).toBe('Database not configured');
-        });
-
-        it('should strip [Frigg] prefix from error messages', () => {
-            getDatabaseTypeFromCore.mockImplementation(() => {
-                throw new Error('[Frigg] No database enabled');
-            });
-
-            const result = getDatabaseType();
-
-            expect(result.error).toBe('No database enabled');
-            expect(result.error).not.toContain('[Frigg]');
-        });
-
-        it('should handle errors without [Frigg] prefix', () => {
-            getDatabaseTypeFromCore.mockImplementation(() => {
-                throw new Error('Custom error message');
-            });
-
-            const result = getDatabaseType();
-
-            expect(result.error).toBe('Custom error message');
-        });
-
-        it('should handle complex error messages', () => {
-            getDatabaseTypeFromCore.mockImplementation(() => {
-                throw new Error('[Frigg] App definition missing database configuration');
-            });
-
-            const result = getDatabaseType();
-
-            expect(result.error).toContain('App definition');
-            expect(result.error).not.toContain('[Frigg]');
-        });
-    });
-
-    describe('testDatabaseConnection()', () => {
-        let mockClient;
-
-        beforeEach(() => {
-            mockClient = createMockPrismaClient();
-            connectPrisma.mockResolvedValue(mockClient);
-            disconnectPrisma.mockResolvedValue(undefined);
-        });
-
-        it('should connect successfully to MongoDB and use $runCommandRaw', async () => {
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(result.connected).toBe(true);
-            expect(result.error).toBeUndefined();
-            expect(connectPrisma).toHaveBeenCalled();
-            expect(mockClient.$runCommandRaw).toHaveBeenCalledWith({ ping: 1 });
-            expect(mockClient.$queryRaw).not.toHaveBeenCalled(); // MongoDB doesn't use SQL
-            expect(disconnectPrisma).toHaveBeenCalled();
-        });
-
-        it('should connect successfully to PostgreSQL and use $queryRaw', async () => {
-            const result = await testDatabaseConnection('postgresql://localhost', 'postgresql');
-
-            expect(result.connected).toBe(true);
-            expect(result.error).toBeUndefined();
-            expect(connectPrisma).toHaveBeenCalled();
-            expect(mockClient.$queryRaw).toHaveBeenCalled();
-            expect(mockClient.$runCommandRaw).not.toHaveBeenCalled(); // PostgreSQL doesn't use Mongo commands
-            expect(disconnectPrisma).toHaveBeenCalled();
-        });
-
-        it('should handle connection timeout', async () => {
-            connectPrisma.mockImplementation(() =>
-                new Promise((resolve) => setTimeout(resolve, 10000))
-            );
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb', 100);
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBe('Connection timeout');
-        });
-
-        it('should handle connection errors', async () => {
-            const error = createPrismaError('CONNECTION_ERROR');
-            connectPrisma.mockRejectedValue(error);
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toContain('reach database server');
-        });
-
-        it('should handle authentication errors', async () => {
-            const error = createPrismaError('AUTH_ERROR');
-            connectPrisma.mockRejectedValue(error);
-
-            const result = await testDatabaseConnection('postgresql://localhost', 'postgresql');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-
-        it('should handle database not found errors', async () => {
-            const error = createPrismaError('DATABASE_NOT_FOUND');
-            connectPrisma.mockRejectedValue(error);
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toContain('does not exist');
-        });
-
-        it('should handle MongoDB command execution errors', async () => {
-            mockClient.$runCommandRaw.mockRejectedValue(new Error('Ping failed'));
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBe('Ping failed');
-        });
-
-        it('should handle PostgreSQL query execution errors', async () => {
-            mockClient.$queryRaw.mockRejectedValue(new Error('Query failed'));
-
-            const result = await testDatabaseConnection('postgresql://localhost', 'postgresql');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBe('Query failed');
-        });
-
-        it('should disconnect even after successful test', async () => {
-            await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(disconnectPrisma).toHaveBeenCalled();
-        });
-
-        it('should handle disconnect errors gracefully', async () => {
-            // Set up successful connection but failing disconnect
-            mockClient.$runCommandRaw.mockResolvedValue({ ok: 1 });
-            disconnectPrisma.mockRejectedValue(new Error('Disconnect failed'));
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            // Should still report success despite disconnect error
-            // Note: Current implementation returns error if ANY exception occurs
-            // This is actually safer behavior, so we accept connected: false
-            expect(result.connected).toBe(false);
-            expect(result.error).toContain('Disconnect failed');
-        });
-
-        it('should attempt disconnect even when connection fails', async () => {
-            connectPrisma.mockRejectedValue(new Error('Connection failed'));
-
-            await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(disconnectPrisma).toHaveBeenCalled();
-        });
-
-        it('should respect custom timeout values', async () => {
-            connectPrisma.mockImplementation(() =>
-                new Promise((resolve) => setTimeout(resolve, 500))
-            );
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb', 100);
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBe('Connection timeout');
-        });
-
-        it('should use default timeout when not specified', async () => {
-            // Mock a slow connection that takes 6 seconds
-            connectPrisma.mockImplementation(() =>
-                new Promise((resolve) => setTimeout(() => resolve(mockClient), 6000))
-            );
-
-            const result = await testDatabaseConnection('mongodb://localhost', 'mongodb');
-
-            expect(result.connected).toBe(false);
-            expect(result.error).toBe('Connection timeout');
-        }, 10000); // Increase timeout to 10 seconds for this test
-    });
-
-    describe('checkPrismaClientGenerated()', () => {
-        // Note: Testing require.resolve behavior requires integration tests with real packages
-        // These unit tests focus on error handling and package name selection
-
-        it('should use correct package name for MongoDB', () => {
-            // When MongoDB client doesn't exist, error message reveals the package name used
-            const result = checkPrismaClientGenerated('mongodb', '/nonexistent/path');
-
-            expect(result.generated).toBe(false);
-            expect(result.error).toContain('@prisma-mongodb/client');
-        });
-
-        it('should use correct package name for PostgreSQL', () => {
-            // When PostgreSQL client doesn't exist, error message reveals the package name used
-            const result = checkPrismaClientGenerated('postgresql', '/nonexistent/path');
-
-            expect(result.generated).toBe(false);
-            expect(result.error).toContain('@prisma-postgresql/client');
-        });
-
-        it('should return error when MongoDB client not found', () => {
-            const result = checkPrismaClientGenerated('mongodb', '/nonexistent/path');
-
-            expect(result.generated).toBe(false);
-            expect(result.error).toBeDefined();
-            expect(result.error).toContain('not found');
-            expect(result.error).toContain('@prisma-mongodb/client');
-            expect(result.error).toContain('frigg db:setup');
-        });
-
-        it('should return error when PostgreSQL client not found', () => {
-            const result = checkPrismaClientGenerated('postgresql', '/nonexistent/path');
-
-            expect(result.generated).toBe(false);
-            expect(result.error).toBeDefined();
-            expect(result.error).toContain('not found');
-            expect(result.error).toContain('@prisma-postgresql/client');
-            expect(result.error).toContain('frigg db:setup');
-        });
-
-        it('should provide helpful error message suggesting db:setup command', () => {
-            const result = checkPrismaClientGenerated('mongodb', '/nonexistent/path');
-
-            expect(result.error).toContain('frigg db:setup');
-        });
-
-        it('should use process.cwd() by default when no project root specified', () => {
-            // We can't easily mock require.resolve, but we can verify it doesn't throw
-            // when called without projectRoot parameter
-            expect(() => {
-                checkPrismaClientGenerated('mongodb');
-            }).not.toThrow();
-        });
-
-        it('should accept custom project root parameter', () => {
-            // Verify custom project root doesn't cause runtime errors
-            const customRoot = '/custom/project/root';
-            const result = checkPrismaClientGenerated('mongodb', customRoot);
-
-            // Should return an error result, not throw
-            expect(result).toHaveProperty('generated');
-            expect(result.generated).toBe(false);
-        });
-    });
-});

package/frigg-cli/__tests__/unit/utils/error-messages.test.js

@@ -1,304 +0,0 @@
-const {
-    DATABASE_URL_EXAMPLES,
-    getDatabaseUrlMissingError,
-    getDatabaseTypeNotConfiguredError,
-    getDatabaseConnectionError,
-    getPrismaClientNotGeneratedError,
-    getPrismaCommandError,
-    getDatabaseSetupSuccess
-} = require('../../../utils/error-messages');
-
-describe('Error Messages Utility', () => {
-    describe('DATABASE_URL_EXAMPLES', () => {
-        it('should include MongoDB connection string example', () => {
-            expect(DATABASE_URL_EXAMPLES.mongodb).toBeDefined();
-            expect(DATABASE_URL_EXAMPLES.mongodb).toContain('mongodb://');
-            expect(DATABASE_URL_EXAMPLES.mongodb).toContain('replicaSet=rs0');
-        });
-
-        it('should include PostgreSQL connection string example', () => {
-            expect(DATABASE_URL_EXAMPLES.postgresql).toBeDefined();
-            expect(DATABASE_URL_EXAMPLES.postgresql).toContain('postgresql://');
-            expect(DATABASE_URL_EXAMPLES.postgresql).toContain('schema=public');
-        });
-    });
-
-    describe('getDatabaseUrlMissingError()', () => {
-        it('should return formatted error message', () => {
-            const message = getDatabaseUrlMissingError();
-
-            expect(message).toBeTruthy();
-            expect(typeof message).toBe('string');
-        });
-
-        it('should include both database type examples', () => {
-            const message = getDatabaseUrlMissingError();
-
-            expect(message).toContain('MongoDB');
-            expect(message).toContain('PostgreSQL');
-        });
-
-        it('should include example connection strings', () => {
-            const message = getDatabaseUrlMissingError();
-
-            expect(message).toContain(DATABASE_URL_EXAMPLES.mongodb);
-            expect(message).toContain(DATABASE_URL_EXAMPLES.postgresql);
-        });
-
-        it('should suggest running frigg db:setup', () => {
-            const message = getDatabaseUrlMissingError();
-
-            expect(message).toContain('frigg db:setup');
-        });
-
-        it('should mention .env file', () => {
-            const message = getDatabaseUrlMissingError();
-
-            expect(message).toContain('.env');
-        });
-    });
-
-    describe('getDatabaseTypeNotConfiguredError()', () => {
-        it('should return formatted error message', () => {
-            const message = getDatabaseTypeNotConfiguredError();
-
-            expect(message).toBeTruthy();
-            expect(typeof message).toBe('string');
-        });
-
-        it('should include PostgreSQL configuration example', () => {
-            const message = getDatabaseTypeNotConfiguredError();
-
-            expect(message).toContain('postgres');
-            expect(message).toContain('enable: true');
-        });
-
-        it('should include MongoDB configuration example', () => {
-            const message = getDatabaseTypeNotConfiguredError();
-
-            expect(message).toContain('mongoDB');
-            expect(message).toContain('enable: true');
-        });
-
-        it('should include DocumentDB configuration example', () => {
-            const message = getDatabaseTypeNotConfiguredError();
-
-            expect(message).toContain('documentDB');
-            expect(message).toContain('enable: true');
-        });
-
-        it('should mention app definition location', () => {
-            const message = getDatabaseTypeNotConfiguredError();
-
-            expect(message).toContain('backend/index.js');
-            expect(message).toContain('index.js');
-        });
-    });
-
-    describe('getDatabaseConnectionError()', () => {
-        const mockError = 'Connection refused';
-
-        it('should include error message for MongoDB', () => {
-            const message = getDatabaseConnectionError(mockError, 'mongodb');
-
-            expect(message).toContain(mockError);
-        });
-
-        it('should include error message for PostgreSQL', () => {
-            const message = getDatabaseConnectionError(mockError, 'postgresql');
-
-            expect(message).toContain(mockError);
-        });
-
-        it('should include MongoDB-specific troubleshooting for MongoDB', () => {
-            const message = getDatabaseConnectionError(mockError, 'mongodb');
-
-            expect(message).toContain('replica set');
-            expect(message).toContain('rs.initiate');
-            expect(message).toContain('mongosh');
-            expect(message).toContain('27017');
-        });
-
-        it('should include PostgreSQL-specific troubleshooting for PostgreSQL', () => {
-            const message = getDatabaseConnectionError(mockError, 'postgresql');
-
-            expect(message).toContain('pg_hba.conf');
-            expect(message).toContain('pg_isready');
-            expect(message).toContain('psql');
-            expect(message).toContain('5432');
-        });
-
-        it('should not include PostgreSQL troubleshooting for MongoDB', () => {
-            const message = getDatabaseConnectionError(mockError, 'mongodb');
-
-            expect(message).not.toContain('pg_hba.conf');
-            expect(message).not.toContain('pg_isready');
-        });
-
-        it('should not include MongoDB troubleshooting for PostgreSQL', () => {
-            const message = getDatabaseConnectionError(mockError, 'postgresql');
-
-            expect(message).not.toContain('replica set');
-            expect(message).not.toContain('rs.initiate');
-        });
-
-        it('should include general troubleshooting steps', () => {
-            const messageMongo = getDatabaseConnectionError(mockError, 'mongodb');
-            const messagePostgres = getDatabaseConnectionError(mockError, 'postgresql');
-
-            expect(messageMongo).toContain('Troubleshooting');
-            expect(messagePostgres).toContain('Troubleshooting');
-        });
-
-        it('should show DATABASE_URL when available', () => {
-            process.env.DATABASE_URL = 'mongodb://test';
-            const message = getDatabaseConnectionError(mockError, 'mongodb');
-
-            expect(message).toContain('mongodb://test');
-            delete process.env.DATABASE_URL;
-        });
-
-        it('should handle missing DATABASE_URL gracefully', () => {
-            delete process.env.DATABASE_URL;
-            const message = getDatabaseConnectionError(mockError, 'mongodb');
-
-            expect(message).toContain('not set');
-        });
-    });
-
-    describe('getPrismaClientNotGeneratedError()', () => {
-        it('should return error message for MongoDB', () => {
-            const message = getPrismaClientNotGeneratedError('mongodb');
-
-            expect(message).toBeTruthy();
-            expect(message).toContain('mongodb');
-        });
-
-        it('should return error message for PostgreSQL', () => {
-            const message = getPrismaClientNotGeneratedError('postgresql');
-
-            expect(message).toBeTruthy();
-            expect(message).toContain('postgresql');
-        });
-
-        it('should include correct client package name for MongoDB', () => {
-            const message = getPrismaClientNotGeneratedError('mongodb');
-
-            expect(message).toContain('@prisma-mongodb/client');
-        });
-
-        it('should include correct client package name for PostgreSQL', () => {
-            const message = getPrismaClientNotGeneratedError('postgresql');
-
-            expect(message).toContain('@prisma-postgresql/client');
-        });
-
-        it('should suggest running frigg db:setup', () => {
-            const message = getPrismaClientNotGeneratedError('mongodb');
-
-            expect(message).toContain('frigg db:setup');
-        });
-
-        it('should explain what will happen when running db:setup', () => {
-            const message = getPrismaClientNotGeneratedError('mongodb');
-
-            expect(message).toContain('Generate the Prisma client');
-            expect(message).toContain('Set up database schema');
-        });
-    });
-
-    describe('getPrismaCommandError()', () => {
-        const mockCommand = 'generate';
-        const mockError = 'Schema validation failed';
-
-        it('should include command name', () => {
-            const message = getPrismaCommandError(mockCommand, mockError);
-
-            expect(message).toContain('generate');
-        });
-
-        it('should include error message', () => {
-            const message = getPrismaCommandError(mockCommand, mockError);
-
-            expect(message).toContain(mockError);
-        });
-
-        it('should list common causes', () => {
-            const message = getPrismaCommandError(mockCommand, mockError);
-
-            expect(message).toContain('Common causes');
-            expect(message).toContain('schema');
-        });
-
-        it('should suggest running frigg db:setup', () => {
-            const message = getPrismaCommandError(mockCommand, mockError);
-
-            expect(message).toContain('frigg db:setup');
-        });
-
-        it('should suggest checking DATABASE_URL', () => {
-            const message = getPrismaCommandError(mockCommand, mockError);
-
-            expect(message).toContain('DATABASE_URL');
-        });
-
-        it('should work with different command names', () => {
-            const migrateMessage = getPrismaCommandError('migrate', mockError);
-            const pushMessage = getPrismaCommandError('db push', mockError);
-
-            expect(migrateMessage).toContain('migrate');
-            expect(pushMessage).toContain('db push');
-        });
-    });
-
-    describe('getDatabaseSetupSuccess()', () => {
-        it('should include database type for MongoDB', () => {
-            const message = getDatabaseSetupSuccess('mongodb', 'development');
-
-            expect(message).toContain('mongodb');
-        });
-
-        it('should include database type for PostgreSQL', () => {
-            const message = getDatabaseSetupSuccess('postgresql', 'production');
-
-            expect(message).toContain('postgresql');
-        });
-
-        it('should include stage information', () => {
-            const devMessage = getDatabaseSetupSuccess('mongodb', 'development');
-            const prodMessage = getDatabaseSetupSuccess('postgresql', 'production');
-
-            expect(devMessage).toContain('development');
-            expect(prodMessage).toContain('production');
-        });
-
-        it('should mention different operations for MongoDB vs PostgreSQL', () => {
-            const mongoMessage = getDatabaseSetupSuccess('mongodb', 'development');
-            const postgresMessage = getDatabaseSetupSuccess('postgresql', 'development');
-
-            expect(mongoMessage).toContain('Schema pushed');
-            expect(postgresMessage).toContain('Migrations applied');
-        });
-
-        it('should suggest next steps', () => {
-            const message = getDatabaseSetupSuccess('mongodb', 'development');
-
-            expect(message).toContain('frigg start');
-            expect(message).toContain('Next steps');
-        });
-
-        it('should confirm what happened during setup', () => {
-            const message = getDatabaseSetupSuccess('mongodb', 'development');
-
-            expect(message).toContain('Prisma client generated');
-            expect(message).toContain('Database connection verified');
-        });
-
-        it('should show success indicators', () => {
-            const message = getDatabaseSetupSuccess('mongodb', 'development');
-
-            expect(message).toContain('successfully');
-            expect(message).toContain('completed');
-        });
-    });
-});