@friggframework/devtools 2.0.0--canary.454.1aa5d6e.0 → 2.0.0--canary.454.83d7e99.0

package/frigg-cli/__tests__/unit/commands/db-setup.test.js

@@ -23,7 +23,7 @@ const mockErrorMessages = {
 };
 
 jest.mock('../../../utils/database-validator', () => mockValidator);
-jest.mock('../../../utils/prisma-runner', () => mockRunner);
+jest.mock('@friggframework/core/database/utils/prisma-runner', () => mockRunner);
 jest.mock('../../../utils/error-messages', () => mockErrorMessages);
 jest.mock('dotenv');
 

package/frigg-cli/db-setup-command/index.js

@@ -12,7 +12,7 @@ const {
     runPrismaMigrate,
     runPrismaDbPush,
     getMigrationCommand
-} = require('../utils/prisma-runner');
+} = require('@friggframework/core/database/utils/prisma-runner');
 const {
     getDatabaseUrlMissingError,
     getDatabaseTypeNotConfiguredError,

package/package.json

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

package/frigg-cli/__tests__/unit/utils/prisma-runner.test.js

@@ -1,486 +0,0 @@
-// Mock dependencies BEFORE requiring modules
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
-    spawn: jest.fn()
-}));
-jest.mock('fs', () => ({
-    existsSync: jest.fn(),
-    readFileSync: jest.fn(),
-    writeFileSync: jest.fn()
-}));
-
-const { execSync, spawn } = require('child_process');
-const fs = require('fs');
-const {
-    getPrismaSchemaPath,
-    runPrismaGenerate,
-    checkDatabaseState,
-    runPrismaMigrate,
-    runPrismaDbPush,
-    getMigrationCommand
-} = require('../../../utils/prisma-runner');
-
-describe('Prisma Runner Utility', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        delete process.env.STAGE;
-        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
-    });
-
-    afterEach(() => {
-        delete process.env.STAGE;
-        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
-    });
-
-    describe('getPrismaSchemaPath()', () => {
-        it('should return correct path for MongoDB', () => {
-            fs.existsSync.mockReturnValue(true);
-
-            const path = getPrismaSchemaPath('mongodb');
-
-            expect(path).toContain('prisma-mongodb');
-            expect(path).toContain('schema.prisma');
-            expect(path).toContain('@friggframework/core');
-        });
-
-        it('should return correct path for PostgreSQL', () => {
-            fs.existsSync.mockReturnValue(true);
-
-            const path = getPrismaSchemaPath('postgresql');
-
-            expect(path).toContain('prisma-postgresql');
-            expect(path).toContain('schema.prisma');
-            expect(path).toContain('@friggframework/core');
-        });
-
-        it('should throw error when schema file does not exist', () => {
-            fs.existsSync.mockReturnValue(false);
-
-            expect(() => getPrismaSchemaPath('mongodb')).toThrow('Prisma schema not found');
-        });
-
-        it('should include helpful error message when schema missing', () => {
-            fs.existsSync.mockReturnValue(false);
-
-            expect(() => getPrismaSchemaPath('mongodb')).toThrow('@friggframework/core');
-        });
-
-        it('should use process.cwd() for base path', () => {
-            fs.existsSync.mockReturnValue(true);
-            const originalCwd = process.cwd();
-
-            const path = getPrismaSchemaPath('mongodb');
-
-            expect(path).toContain(originalCwd);
-        });
-
-        it('should accept custom project root', () => {
-            fs.existsSync.mockReturnValue(true);
-            const customRoot = '/custom/project';
-
-            const path = getPrismaSchemaPath('mongodb', customRoot);
-
-            expect(path).toContain(customRoot);
-        });
-    });
-
-    describe('runPrismaGenerate()', () => {
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-        });
-
-        it('should execute prisma generate successfully', async () => {
-            execSync.mockReturnValue('Generated successfully');
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(true);
-            expect(execSync).toHaveBeenCalled();
-        });
-
-        it('should use correct schema path for MongoDB', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb');
-
-            const call = execSync.mock.calls[0][0];
-            expect(call).toContain('prisma generate');
-            expect(call).toContain('--schema');
-            expect(call).toContain('prisma-mongodb');
-        });
-
-        it('should use correct schema path for PostgreSQL', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('postgresql');
-
-            const call = execSync.mock.calls[0][0];
-            expect(call).toContain('prisma-postgresql');
-        });
-
-        it('should suppress telemetry when verbose false', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb', false);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
-        });
-
-        it('should show output when verbose true', async () => {
-            execSync.mockReturnValue('Generated successfully');
-
-            await runPrismaGenerate('mongodb', true);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should hide output when verbose false', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb', false);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.stdio).toBe('pipe');
-        });
-
-        it('should handle generation failures with error details', async () => {
-            const error = new Error('Generation failed');
-            error.stdout = 'Schema validation error';
-            execSync.mockImplementation(() => {
-                throw error;
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('Generation failed');
-        });
-
-        it('should include stdout in error output', async () => {
-            const error = new Error('Failed');
-            error.stdout = Buffer.from('Detailed error info');
-            execSync.mockImplementation(() => {
-                throw error;
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.output).toContain('Detailed error info');
-        });
-
-        it('should handle schema syntax errors', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('Schema parsing failed');
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-    });
-
-    describe('checkDatabaseState()', () => {
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-        });
-
-        it('should return upToDate: true when migrations current (PostgreSQL)', async () => {
-            execSync.mockReturnValue('Database schema is up to date');
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(true);
-        });
-
-        it('should return upToDate: true for MongoDB (N/A)', async () => {
-            const result = await checkDatabaseState('mongodb');
-
-            expect(result.upToDate).toBe(true);
-        });
-
-        it('should return pendingMigrations count when migrations pending', async () => {
-            execSync.mockReturnValue('3 migrations have not been applied');
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.pendingMigrations).toBe(3);
-        });
-
-        it('should handle uninitialized database', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('No migrations found');
-            });
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-
-        it('should handle migrate status command errors', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('Migration status failed');
-            });
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.error).toContain('Migration status failed');
-        });
-
-        it('should not run migrate status for MongoDB', async () => {
-            await checkDatabaseState('mongodb');
-
-            expect(execSync).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('runPrismaMigrate()', () => {
-        let mockChildProcess;
-
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-            mockChildProcess = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        callback(0);
-                    }
-                }),
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() }
-            };
-            spawn.mockReturnValue(mockChildProcess);
-        });
-
-        it('should run migrate dev successfully', async () => {
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should run migrate deploy successfully', async () => {
-            const result = await runPrismaMigrate('deploy');
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should use correct command for dev mode', async () => {
-            await runPrismaMigrate('dev');
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('migrate');
-            expect(args).toContain('dev');
-        });
-
-        it('should use correct command for deploy mode', async () => {
-            await runPrismaMigrate('deploy');
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('migrate');
-            expect(args).toContain('deploy');
-        });
-
-        it('should handle migration failures with error', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1); // Exit code 1
-                }
-            });
-
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('exited with code 1');
-        });
-
-        it('should respect verbose flag', async () => {
-            await runPrismaMigrate('dev', true);
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should handle process spawn errors', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'error') {
-                    callback(new Error('Spawn failed'));
-                }
-            });
-
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(false);
-        });
-
-        it('should hide telemetry messages', async () => {
-            await runPrismaMigrate('dev');
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
-        });
-    });
-
-    describe('runPrismaDbPush()', () => {
-        let mockChildProcess;
-
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-            mockChildProcess = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        callback(0);
-                    }
-                }),
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() }
-            };
-            spawn.mockReturnValue(mockChildProcess);
-        });
-
-        it('should push schema successfully for MongoDB', async () => {
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should use --skip-generate flag', async () => {
-            await runPrismaDbPush();
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('--skip-generate');
-        });
-
-        it('should use db push command', async () => {
-            await runPrismaDbPush();
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('db');
-            expect(args).toContain('push');
-        });
-
-        it('should handle push failures with error', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1);
-                }
-            });
-
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('exited with code 1');
-        });
-
-        it('should respect verbose flag', async () => {
-            await runPrismaDbPush(true);
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should use interactive mode (stdio: inherit)', async () => {
-            await runPrismaDbPush();
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should handle schema validation errors', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1);
-                }
-            });
-
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(false);
-        });
-    });
-
-    describe('getMigrationCommand()', () => {
-        it('should return dev for development stage', () => {
-            const command = getMigrationCommand('development');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for dev stage', () => {
-            const command = getMigrationCommand('dev');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for local stage', () => {
-            const command = getMigrationCommand('local');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for test stage', () => {
-            const command = getMigrationCommand('test');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return deploy for production stage', () => {
-            const command = getMigrationCommand('production');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should return deploy for prod stage', () => {
-            const command = getMigrationCommand('prod');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should return deploy for staging stage', () => {
-            const command = getMigrationCommand('staging');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should default to dev when stage undefined', () => {
-            const command = getMigrationCommand();
-
-            expect(command).toBe('dev');
-        });
-
-        it('should read from STAGE environment variable when no argument', () => {
-            process.env.STAGE = 'production';
-
-            const command = getMigrationCommand();
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should prioritize argument over STAGE env var', () => {
-            process.env.STAGE = 'production';
-
-            const command = getMigrationCommand('development');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should handle case-insensitive stage names', () => {
-            expect(getMigrationCommand('DEVELOPMENT')).toBe('dev');
-            expect(getMigrationCommand('PRODUCTION')).toBe('deploy');
-            expect(getMigrationCommand('Dev')).toBe('dev');
-            expect(getMigrationCommand('Prod')).toBe('deploy');
-        });
-
-        it('should return deploy for unknown stages', () => {
-            const command = getMigrationCommand('unknown-stage');
-
-            expect(command).toBe('deploy');
-        });
-    });
-});

package/frigg-cli/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
-};