@friggframework/core 2.0.0--canary.454.e2a280d.0 → 2.0.0--canary.459.51231dd.0

package/database/use-cases/run-database-migration-use-case.test.js

@@ -1,310 +0,0 @@
-/**
- * Tests for Run Database Migration Use Case
- */
-
-const {
-    RunDatabaseMigrationUseCase,
-    MigrationError,
-    ValidationError,
-} = require('./run-database-migration-use-case');
-
-describe('RunDatabaseMigrationUseCase', () => {
-    let useCase;
-    let mockPrismaRunner;
-
-    beforeEach(() => {
-        // Mock prisma runner with all required methods
-        mockPrismaRunner = {
-            runPrismaGenerate: jest.fn(),
-            runPrismaMigrate: jest.fn(),
-            runPrismaDbPush: jest.fn(),
-            getMigrationCommand: jest.fn(),
-        };
-
-        useCase = new RunDatabaseMigrationUseCase({ prismaRunner: mockPrismaRunner });
-    });
-
-    describe('Constructor', () => {
-        it('should throw error if prismaRunner is not provided', () => {
-            expect(() => new RunDatabaseMigrationUseCase({})).toThrow('prismaRunner dependency is required');
-        });
-
-        it('should create instance with valid dependencies', () => {
-            expect(useCase).toBeInstanceOf(RunDatabaseMigrationUseCase);
-            expect(useCase.prismaRunner).toBe(mockPrismaRunner);
-        });
-    });
-
-    describe('Parameter Validation', () => {
-        it('should throw ValidationError if dbType is missing', async () => {
-            await expect(useCase.execute({ stage: 'production' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ stage: 'production' })).rejects.toThrow('dbType is required');
-        });
-
-        it('should throw ValidationError if dbType is not a string', async () => {
-            await expect(useCase.execute({ dbType: 123, stage: 'production' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 123, stage: 'production' })).rejects.toThrow(
-                'dbType must be a string'
-            );
-        });
-
-        it('should throw ValidationError if stage is missing', async () => {
-            await expect(useCase.execute({ dbType: 'postgresql' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 'postgresql' })).rejects.toThrow('stage is required');
-        });
-
-        it('should throw ValidationError if stage is not a string', async () => {
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 123 })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 123 })).rejects.toThrow(
-                'stage must be a string'
-            );
-        });
-    });
-
-    describe('PostgreSQL Migrations', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({ success: true });
-        });
-
-        it('should successfully run PostgreSQL production migration', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-
-            const result = await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(result).toEqual({
-                success: true,
-                dbType: 'postgresql',
-                stage: 'production',
-                command: 'deploy',
-                message: 'Database migration completed successfully',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', true);
-            expect(mockPrismaRunner.getMigrationCommand).toHaveBeenCalledWith('production');
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', true);
-            expect(mockPrismaRunner.runPrismaDbPush).not.toHaveBeenCalled();
-        });
-
-        it('should successfully run PostgreSQL development migration', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('dev');
-
-            const result = await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'dev',
-            });
-
-            expect(result.success).toBe(true);
-            expect(result.command).toBe('dev');
-            expect(mockPrismaRunner.getMigrationCommand).toHaveBeenCalledWith('dev');
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('dev', false);
-        });
-
-        it('should throw MigrationError if Prisma generate fails', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({
-                success: false,
-                error: 'Schema file not found',
-                output: 'Error output',
-            });
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow(MigrationError);
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow('Failed to generate Prisma client: Schema file not found');
-
-            expect(mockPrismaRunner.runPrismaMigrate).not.toHaveBeenCalled();
-        });
-
-        it('should throw MigrationError if PostgreSQL migration fails', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: 'Migration conflict detected',
-                output: 'Conflict output',
-            });
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow(MigrationError);
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow('PostgreSQL migration failed: Migration conflict detected');
-        });
-
-        it('should include context in MigrationError', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: 'Migration failed',
-                output: 'Error output',
-            });
-
-            try {
-                await useCase.execute({ dbType: 'postgresql', stage: 'production' });
-                fail('Should have thrown MigrationError');
-            } catch (error) {
-                expect(error).toBeInstanceOf(MigrationError);
-                expect(error.context).toEqual({
-                    dbType: 'postgresql',
-                    stage: 'production',
-                    command: 'deploy',
-                    step: 'migrate',
-                    output: 'Error output',
-                });
-            }
-        });
-    });
-
-    describe('MongoDB Migrations', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({ success: true });
-        });
-
-        it('should successfully run MongoDB migration', async () => {
-            const result = await useCase.execute({
-                dbType: 'mongodb',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(result).toEqual({
-                success: true,
-                dbType: 'mongodb',
-                stage: 'production',
-                command: 'db push',
-                message: 'Database migration completed successfully',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
-            expect(mockPrismaRunner.runPrismaDbPush).toHaveBeenCalledWith(true, true); // verbose=true, nonInteractive=true
-            expect(mockPrismaRunner.runPrismaMigrate).not.toHaveBeenCalled();
-        });
-
-        it('should use non-interactive mode for MongoDB', async () => {
-            await useCase.execute({
-                dbType: 'mongodb',
-                stage: 'production',
-            });
-
-            // Second parameter should be true for non-interactive
-            expect(mockPrismaRunner.runPrismaDbPush).toHaveBeenCalledWith(false, true);
-        });
-
-        it('should throw MigrationError if MongoDB push fails', async () => {
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({
-                success: false,
-                error: 'Connection timeout',
-            });
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                MigrationError
-            );
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                'MongoDB push failed: Connection timeout'
-            );
-        });
-    });
-
-    describe('Unsupported Database Types', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-        });
-
-        it('should throw ValidationError for unsupported database type', async () => {
-            await expect(useCase.execute({ dbType: 'mysql', stage: 'production' })).rejects.toThrow(
-                ValidationError
-            );
-
-            await expect(useCase.execute({ dbType: 'mysql', stage: 'production' })).rejects.toThrow(
-                "Unsupported database type: mysql. Must be 'postgresql' or 'mongodb'."
-            );
-        });
-
-        it('should run Prisma generate before checking database type', async () => {
-            try {
-                await useCase.execute({ dbType: 'mysql', stage: 'production' });
-            } catch (error) {
-                // Expected error
-            }
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('mysql', false);
-        });
-    });
-
-    describe('Error Handling', () => {
-        it('should handle undefined error from Prisma generate', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 'production' })).rejects.toThrow(
-                'Failed to generate Prisma client: Unknown error'
-            );
-        });
-
-        it('should handle undefined error from PostgreSQL migration', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 'production' })).rejects.toThrow(
-                'PostgreSQL migration failed: Unknown error'
-            );
-        });
-
-        it('should handle undefined error from MongoDB push', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                'MongoDB push failed: Unknown error'
-            );
-        });
-    });
-
-    describe('Verbose Mode', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({ success: true });
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-        });
-
-        it('should pass verbose flag to all Prisma operations', async () => {
-            await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', true);
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', true);
-        });
-
-        it('should default verbose to false', async () => {
-            await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', false);
-        });
-    });
-});

package/database/utils/prisma-runner.js

@@ -1,313 +0,0 @@
-const { execSync, spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const chalk = require('chalk');
-
-/**
- * Prisma Command Runner Utility
- * Handles execution of Prisma CLI commands for database setup
- */
-
-/**
- * Gets the path to the Prisma schema file for the database type
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @param {string} projectRoot - Project root directory
- * @returns {string} Absolute path to schema file
- * @throws {Error} If schema file doesn't exist
- */
-function getPrismaSchemaPath(dbType, projectRoot = process.cwd()) {
-    // Try multiple locations for the schema file
-    // Priority order:
-    // 1. Local node_modules (where @friggframework/core is installed - production scenario)
-    // 2. Parent node_modules (workspace/monorepo setup)
-    const possiblePaths = [
-        // Check where Frigg is installed via npm (production scenario)
-        path.join(projectRoot, 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma'),
-        path.join(projectRoot, '..', 'node_modules', '@friggframework', 'core', `prisma-${dbType}`, 'schema.prisma')
-    ];
-
-    for (const schemaPath of possiblePaths) {
-        if (fs.existsSync(schemaPath)) {
-            return schemaPath;
-        }
-    }
-
-    // If not found in any location, throw error
-    throw new Error(
-        `Prisma schema not found at:\n${possiblePaths.join('\n')}\n\n` +
-        'Ensure @friggframework/core is installed.'
-    );
-}
-
-/**
- * Runs prisma generate for the specified database type
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @param {boolean} verbose - Enable verbose output
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaGenerate(dbType, verbose = false) {
-    try {
-        const schemaPath = getPrismaSchemaPath(dbType);
-
-        if (verbose) {
-            console.log(chalk.gray(`Running: npx prisma generate --schema=${schemaPath}`));
-        }
-
-        const output = execSync(
-            `npx prisma generate --schema=${schemaPath}`,
-            {
-                encoding: 'utf8',
-                stdio: verbose ? 'inherit' : 'pipe',
-                env: {
-                    ...process.env,
-                    // Suppress Prisma telemetry prompts
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
-
-        return {
-            success: true,
-            output: verbose ? 'Generated successfully' : output
-        };
-
-    } catch (error) {
-        return {
-            success: false,
-            error: error.message,
-            output: error.stdout?.toString() || error.stderr?.toString()
-        };
-    }
-}
-
-/**
- * Checks database migration status
- * @param {'mongodb'|'postgresql'} dbType - Database type
- * @returns {Promise<Object>} { upToDate: boolean, pendingMigrations?: number, error?: string }
- */
-async function checkDatabaseState(dbType) {
-    try {
-        // Only applicable for PostgreSQL (MongoDB uses db push)
-        if (dbType !== 'postgresql') {
-            return { upToDate: true };
-        }
-
-        const schemaPath = getPrismaSchemaPath(dbType);
-
-        const output = execSync(
-            `npx prisma migrate status --schema=${schemaPath}`,
-            {
-                encoding: 'utf8',
-                stdio: 'pipe',
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            }
-        );
-
-        if (output.includes('Database schema is up to date')) {
-            return { upToDate: true };
-        }
-
-        // Parse pending migrations count
-        const pendingMatch = output.match(/(\d+) migration/);
-        const pendingMigrations = pendingMatch ? parseInt(pendingMatch[1]) : 0;
-
-        return {
-            upToDate: false,
-            pendingMigrations
-        };
-
-    } catch (error) {
-        // If migrate status fails, database might not be initialized
-        return {
-            upToDate: false,
-            error: error.message
-        };
-    }
-}
-
-/**
- * Runs Prisma migrate for PostgreSQL
- * @param {'dev'|'deploy'} command - Migration command (dev or deploy)
- * @param {boolean} verbose - Enable verbose output
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaMigrate(command = 'dev', verbose = false) {
-    return new Promise((resolve) => {
-        try {
-            const schemaPath = getPrismaSchemaPath('postgresql');
-
-            const args = [
-                'prisma',
-                'migrate',
-                command,
-                '--schema',
-                schemaPath
-            ];
-
-            if (verbose) {
-                console.log(chalk.gray(`Running: npx ${args.join(' ')}`));
-            }
-
-            const proc = spawn('npx', args, {
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            });
-
-            proc.on('error', (error) => {
-                resolve({
-                    success: false,
-                    error: error.message
-                });
-            });
-
-            proc.on('close', (code) => {
-                if (code === 0) {
-                    resolve({
-                        success: true,
-                        output: 'Migration completed successfully'
-                    });
-                } else {
-                    resolve({
-                        success: false,
-                        error: `Migration process exited with code ${code}`
-                    });
-                }
-            });
-
-        } catch (error) {
-            resolve({
-                success: false,
-                error: error.message
-            });
-        }
-    });
-}
-
-/**
- * Runs Prisma db push for MongoDB
- * @param {boolean} verbose - Enable verbose output
- * @param {boolean} nonInteractive - Run in non-interactive mode (accepts data loss, for Lambda/CI)
- * @returns {Promise<Object>} { success: boolean, output?: string, error?: string }
- */
-async function runPrismaDbPush(verbose = false, nonInteractive = false) {
-    return new Promise((resolve) => {
-        try {
-            const schemaPath = getPrismaSchemaPath('mongodb');
-
-            const args = [
-                'prisma',
-                'db',
-                'push',
-                '--schema',
-                schemaPath,
-                '--skip-generate' // We generate separately
-            ];
-
-            // Add non-interactive flag for Lambda/CI environments
-            if (nonInteractive) {
-                args.push('--accept-data-loss');
-            }
-
-            if (verbose) {
-                console.log(chalk.gray(`Running: npx ${args.join(' ')}`));
-            }
-
-            if (nonInteractive) {
-                console.log(chalk.yellow('⚠️  Non-interactive mode: Data loss will be automatically accepted'));
-            } else {
-                console.log(chalk.yellow('⚠️  Interactive mode: You may be prompted if schema changes cause data loss'));
-            }
-
-            const proc = spawn('npx', args, {
-                stdio: nonInteractive ? 'pipe' : 'inherit', // Use pipe for non-interactive to capture output
-                env: {
-                    ...process.env,
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1'
-                }
-            });
-
-            let stdout = '';
-            let stderr = '';
-
-            // Capture output in non-interactive mode
-            if (nonInteractive) {
-                if (proc.stdout) {
-                    proc.stdout.on('data', (data) => {
-                        stdout += data.toString();
-                        if (verbose) {
-                            process.stdout.write(data);
-                        }
-                    });
-                }
-                if (proc.stderr) {
-                    proc.stderr.on('data', (data) => {
-                        stderr += data.toString();
-                        if (verbose) {
-                            process.stderr.write(data);
-                        }
-                    });
-                }
-            }
-
-            proc.on('error', (error) => {
-                resolve({
-                    success: false,
-                    error: error.message
-                });
-            });
-
-            proc.on('close', (code) => {
-                if (code === 0) {
-                    resolve({
-                        success: true,
-                        output: nonInteractive ? stdout || 'Database push completed successfully' : 'Database push completed successfully'
-                    });
-                } else {
-                    resolve({
-                        success: false,
-                        error: `Database push process exited with code ${code}`,
-                        output: stderr || stdout
-                    });
-                }
-            });
-
-        } catch (error) {
-            resolve({
-                success: false,
-                error: error.message
-            });
-        }
-    });
-}
-
-/**
- * Determines migration command based on STAGE environment variable
- * @param {string} stage - Stage from CLI option or environment
- * @returns {'dev'|'deploy'}
- */
-function getMigrationCommand(stage) {
-    const normalizedStage = (stage || process.env.STAGE || 'development').toLowerCase();
-
-    const developmentStages = ['dev', 'local', 'test', 'development'];
-
-    if (developmentStages.includes(normalizedStage)) {
-        return 'dev';
-    }
-
-    return 'deploy';
-}
-
-module.exports = {
-    getPrismaSchemaPath,
-    runPrismaGenerate,
-    checkDatabaseState,
-    runPrismaMigrate,
-    runPrismaDbPush,
-    getMigrationCommand
-};