@hed-hog/cli 0.0.12

package/dist/src/modules/developer/developer.service.js

@@ -0,0 +1,900 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeveloperService = void 0;
+const common_1 = require("@nestjs/common");
+const chalk = require("chalk");
+const crypto_1 = require("crypto");
+const ejs_1 = require("ejs");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const inquirer_1 = require("inquirer");
+const ora = require("ora");
+const pathModule = require("path");
+const to_pascal_case_1 = require("../../functions/to-pascal-case");
+const database_service_1 = require("../database/database.service");
+const file_system_service_1 = require("../hedhog/services/file-system.service");
+const runner_service_1 = require("../runner/runner.service");
+let DeveloperService = class DeveloperService {
+    runner;
+    fileSystem;
+    database;
+    verbose = false;
+    constructor(runner, fileSystem, database) {
+        this.runner = runner;
+        this.fileSystem = fileSystem;
+        this.database = database;
+    }
+    log(...args) {
+        if (this.verbose) {
+            console.log('\n', ...args);
+        }
+    }
+    async route(path, verbose = false) {
+        this.verbose = verbose;
+        const spinner = ora('Analyzing NestJS routes...').start();
+        try {
+            path = await this.getRootPath(path);
+            const apiPath = pathModule.join(path, 'apps', 'api');
+            if (!(0, fs_1.existsSync)(apiPath)) {
+                spinner.fail('API directory not found. Make sure you are in a NestJS project.');
+                return;
+            }
+            // Find main.ts
+            const mainPath = pathModule.join(apiPath, 'src', 'main.ts');
+            if (!(0, fs_1.existsSync)(mainPath)) {
+                spinner.fail('main.ts not found.');
+                return;
+            }
+            spinner.text = 'Reading main.ts...';
+            const mainContent = await (0, promises_1.readFile)(mainPath, 'utf8');
+            const mainModuleName = this.extractMainModule(mainContent);
+            if (!mainModuleName) {
+                spinner.fail('Could not determine main module from main.ts');
+                return;
+            }
+            this.log(chalk.blue(`Main module: ${mainModuleName}`));
+            // Find app.module.ts
+            const appModulePath = pathModule.join(apiPath, 'src', 'app.module.ts');
+            if (!(0, fs_1.existsSync)(appModulePath)) {
+                spinner.fail('app.module.ts not found.');
+                return;
+            }
+            spinner.text = 'Scanning controllers...';
+            const routes = await this.extractRoutes(apiPath);
+            spinner.succeed('Routes extracted successfully.');
+            if (routes.length === 0) {
+                console.log(chalk.yellow('\nNo routes found.'));
+                return;
+            }
+            // Display routes
+            console.log(chalk.green.bold('\n📋 Routes found:\n'));
+            const groupedRoutes = this.groupRoutesByController(routes);
+            for (const [controller, controllerRoutes] of Object.entries(groupedRoutes)) {
+                console.log(chalk.cyan.bold(`\n${controller}:`));
+                controllerRoutes.forEach((route) => {
+                    const methodColor = this.getMethodColor(route.method);
+                    const method = route.method.padEnd(7);
+                    console.log(`  ${methodColor(method)} ${chalk.white(route.path)}`);
+                });
+            }
+            console.log(chalk.gray(`\nTotal routes: ${routes.length}\n`));
+        }
+        catch (error) {
+            spinner.fail('Failed to analyze routes.');
+            console.error(chalk.red('Error analyzing routes:'), error);
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    extractMainModule(content) {
+        // Look for patterns like: bootstrap(AppModule) or .create(AppModule)
+        const patterns = [
+            /NestFactory\.create\((\w+)\)/,
+            /bootstrap\((\w+)\)/,
+            /\.create\((\w+)\)/,
+        ];
+        for (const pattern of patterns) {
+            const match = content.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    async extractRoutes(apiPath) {
+        const routes = [];
+        const srcPath = pathModule.join(apiPath, 'src');
+        const findControllers = async (dir) => {
+            const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = pathModule.join(dir, entry.name);
+                if (entry.isDirectory() && entry.name !== 'node_modules') {
+                    await findControllers(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.controller.ts')) {
+                    const controllerRoutes = await this.parseController(fullPath);
+                    routes.push(...controllerRoutes);
+                }
+            }
+        };
+        await findControllers(srcPath);
+        return routes;
+    }
+    async parseController(filePath) {
+        const content = await (0, promises_1.readFile)(filePath, 'utf8');
+        const routes = [];
+        // Extract controller name and base path
+        const controllerMatch = content.match(/@Controller\(['"](.*?)['"]\)/);
+        const basePath = controllerMatch ? controllerMatch[1] : '';
+        // Extract class name
+        const classMatch = content.match(/export\s+class\s+(\w+Controller)/);
+        const controllerName = classMatch
+            ? classMatch[1]
+            : pathModule.basename(filePath, '.ts');
+        // HTTP methods to look for
+        const httpMethods = [
+            'Get',
+            'Post',
+            'Put',
+            'Delete',
+            'Patch',
+            'Options',
+            'Head',
+        ];
+        for (const method of httpMethods) {
+            // Match patterns like @Get(), @Get('path'), @Get(':id')
+            const methodRegex = new RegExp(`@${method}\\((?:['"](.*?)['"])?\\)`, 'g');
+            let match;
+            while ((match = methodRegex.exec(content)) !== null) {
+                const routePath = match[1] || '';
+                const fullPath = this.buildFullPath(basePath, routePath);
+                routes.push({
+                    controller: controllerName,
+                    method: method.toUpperCase(),
+                    path: fullPath,
+                    filePath,
+                });
+            }
+        }
+        return routes;
+    }
+    buildFullPath(basePath, routePath) {
+        const base = basePath.startsWith('/') ? basePath : `/${basePath}`;
+        const route = routePath.startsWith('/') ? routePath : `/${routePath}`;
+        if (!routePath) {
+            return base || '/';
+        }
+        if (!basePath) {
+            return route;
+        }
+        return `${base}${route}`.replace(/\/+/g, '/');
+    }
+    groupRoutesByController(routes) {
+        const grouped = {};
+        for (const route of routes) {
+            if (!grouped[route.controller]) {
+                grouped[route.controller] = [];
+            }
+            grouped[route.controller].push({
+                method: route.method,
+                path: route.path,
+            });
+        }
+        // Sort routes within each controller
+        for (const controller in grouped) {
+            grouped[controller].sort((a, b) => {
+                if (a.path !== b.path) {
+                    return a.path.localeCompare(b.path);
+                }
+                return a.method.localeCompare(b.method);
+            });
+        }
+        return grouped;
+    }
+    getMethodColor(method) {
+        const colors = {
+            GET: chalk.green,
+            POST: chalk.blue,
+            PUT: chalk.yellow,
+            DELETE: chalk.red,
+            PATCH: chalk.magenta,
+            OPTIONS: chalk.gray,
+            HEAD: chalk.cyan,
+        };
+        return colors[method] || chalk.white;
+    }
+    async createLibrary(path, libraryName, force = false, verbose = false, skipInstall = false) {
+        this.verbose = verbose;
+        this.log(chalk.blue('Starting library creation...'));
+        if (!libraryName) {
+            console.error(chalk.red('Library name is required.'));
+            return;
+        }
+        const libraryPath = pathModule.join(path, 'libraries', libraryName);
+        if ((0, fs_1.existsSync)(libraryPath)) {
+            if (force) {
+                this.log(chalk.yellow(`Library ${libraryName} already exists. Overwriting...`));
+            }
+            else {
+                console.error(chalk.red(`Library ${libraryName} already exists.`));
+                return;
+            }
+        }
+        await (0, promises_1.mkdir)(pathModule.join(libraryPath, 'src'), { recursive: true });
+        this.log(chalk.green(`Created directory: ${libraryPath}/src`));
+        const vars = {
+            path,
+            libraryPath,
+            libraryNamePascalCase: this.toPascalCase(libraryName),
+            libraryNameSnackCase: this.toSnackCase(libraryName),
+            libraryNameCamelCase: this.toCamelCase(libraryName),
+            libraryNameKebabCase: this.toKebabCase(libraryName),
+            libraryName: libraryName,
+        };
+        const files = [
+            {
+                template: '.eslintrc.js.ejs',
+                destination: `/.eslintrc.js`,
+            },
+            {
+                template: '.prettierrc.js.ejs',
+                destination: `/.prettierrc.js`,
+            },
+            {
+                template: 'package.json.ejs',
+                destination: `/package.json`,
+            },
+            {
+                template: 'tsconfig.json.ejs',
+                destination: `/tsconfig.json`,
+            },
+            {
+                template: 'tsconfig.production.json.ejs',
+                destination: `/tsconfig.production.json`,
+            },
+            {
+                template: 'module.ts.ejs',
+                destination: `/src/${vars.libraryNameKebabCase}.module.ts`,
+            },
+            {
+                template: 'index.ts.ejs',
+                destination: `/src/index.ts`,
+            },
+        ];
+        for (const file of files) {
+            const templatePath = pathModule.join(__dirname, '..', '..', 'templates', 'library', file.template);
+            const destinationPath = pathModule.join(path, 'libraries', libraryName, file.destination);
+            this.log(chalk.blue(`Rendering template: ${file.template}`));
+            const content = await (0, promises_1.readFile)(templatePath, 'utf8');
+            const renderedContent = await (0, ejs_1.render)(content, vars);
+            await (0, promises_1.writeFile)(destinationPath, renderedContent, 'utf8');
+            this.log(chalk.blue(`Created file: ${destinationPath}`));
+        }
+        this.log(chalk.green('Library files created successfully.'));
+        await this.updateTsconfigFiles(path, verbose);
+        if (!skipInstall) {
+            this.log(chalk.blue(`Installing dependencies for ${libraryName}...`));
+            await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['install'], {
+                cwd: libraryPath,
+            }, true);
+            this.log(chalk.green(`Dependencies installed for ${libraryName}.`));
+        }
+        this.log(chalk.green(`Library ${libraryName} created successfully at ${libraryPath}.`));
+    }
+    async hashDirectory(path) {
+        const sum = (0, crypto_1.createHash)('sha256');
+        const paths = [];
+        async function scanDirectory(dir) {
+            const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name === 'node_modules')
+                    continue;
+                const path = `${dir}/${entry.name}`;
+                if (entry.isDirectory()) {
+                    await scanDirectory(path);
+                }
+                else {
+                    const fileContent = await (0, promises_1.readFile)(path, 'utf8');
+                    paths.push({ path, content: fileContent });
+                }
+            }
+        }
+        await scanDirectory(path);
+        const hash = sum.update(JSON.stringify(paths)).digest('hex');
+        return hash;
+    }
+    async updateTsconfigFiles(path, verbose = false) {
+        this.verbose = verbose;
+        this.log(chalk.blue('Updating tsconfig files...'));
+        const directories = [];
+        const scanDirs = ['libraries', 'packages'];
+        try {
+            for (const dir of scanDirs) {
+                const baseDir = pathModule.join(path, dir);
+                if (!(0, fs_1.existsSync)(baseDir) || !(0, fs_1.statSync)(baseDir).isDirectory())
+                    continue;
+                const subDirs = (0, fs_1.readdirSync)(baseDir, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => pathModule.join(baseDir, entry.name));
+                for (const subDir of subDirs) {
+                    const tsconfigPath = pathModule.join(subDir, 'tsconfig.json');
+                    const tsconfigProdPath = pathModule.join(subDir, 'tsconfig.production.json');
+                    if ((0, fs_1.existsSync)(tsconfigPath) || (0, fs_1.existsSync)(tsconfigProdPath)) {
+                        directories.push(subDir);
+                        this.log(chalk.blue(`Found tsconfig in: ${subDir}`));
+                    }
+                }
+            }
+            const destinationPath = '/packages/typescript-config';
+            this.log(chalk.blue('Loading base tsconfig...'));
+            const baseData = require(pathModule.join(path, destinationPath, 'base.json'));
+            baseData.compilerOptions.paths = {
+                '@prisma/client': [
+                    '../../packages/api-prisma/node_modules/.prisma/client',
+                ],
+                '@prisma/client/*': [
+                    '../../packages/api-prisma/node_modules/.prisma/client/*',
+                ],
+            };
+            for (const subDir of directories) {
+                const packageName = require(pathModule.join(subDir, 'package.json')).name;
+                const relativePath = subDir.split(pathModule.sep).slice(-2);
+                baseData.compilerOptions.paths[packageName] = [
+                    `../../${relativePath.join('/')}/src`,
+                ];
+                baseData.compilerOptions.paths[`${packageName}/*`] = [
+                    `../../${relativePath.join('/')}/src/*`,
+                ];
+                this.log(chalk.blue(`Added path mapping for: ${packageName}`));
+            }
+            await (0, promises_1.writeFile)(pathModule.join(path, destinationPath, 'base.json'), JSON.stringify(baseData, null, 2), 'utf-8');
+            this.log(chalk.green('Updated base tsconfig.json successfully.'));
+        }
+        catch (error) {
+            console.error(error);
+            this.log(chalk.red('Failed to update tsconfig files.'));
+        }
+    }
+    toCamelCase(str) {
+        return str
+            .replace(/[-_](\w)/g, (_, c) => (c ? c.toUpperCase() : ''))
+            .replace(/^\w/, (c) => c.toLowerCase());
+    }
+    toKebabCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[_\s]+/g, '-')
+            .toLowerCase();
+    }
+    toPascalCase(str) {
+        return (0, to_pascal_case_1.toPascalCase)(str);
+    }
+    toSnackCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[_\s]+/g, '-')
+            .toLowerCase()
+            .replace(/-/g, '_');
+    }
+    async resetDevelopmentEnvironment(cwd, verbose = false) {
+        this.verbose = verbose;
+        const spinner = ora('Resetting development environment...').start();
+        try {
+            await this.removeLibrariesDirectory(cwd, spinner);
+            await this.removeMigrationFiles(cwd, spinner);
+            await this.resetAppModuleFile(cwd, spinner);
+            await this.resetPackageJsonFile(cwd, spinner);
+            await this.resetDatabase(cwd, spinner);
+            await this.resetHedhogFile(cwd, spinner);
+        }
+        catch (error) {
+            spinner.fail('Failed to reset development environment.');
+            console.error(chalk.red('Error resetting development environment:'), error);
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    async resetHedhogFile(cwd, spinner) {
+        this.log('Resetting .hedhog file...');
+        spinner.start('Resetting .hedhog file...');
+        const hedHogFilePath = pathModule.join(cwd, 'hedhog.json');
+        if ((0, fs_1.existsSync)(hedHogFilePath)) {
+            try {
+                const currentFileParsed = JSON.parse(await this.fileSystem.readFileAsString(hedHogFilePath));
+                spinner.text =
+                    'Loaded existing hedhog.json file. Resetting contents...';
+                currentFileParsed.libraries = [];
+                currentFileParsed.installed = false;
+                currentFileParsed.developerMode = false;
+                currentFileParsed.buildCache = {};
+                await this.fileSystem.writeJsonFile(hedHogFilePath, currentFileParsed);
+                spinner.text = 'hedhog.json file reset.';
+                this.log('hedhog.json file reset.');
+                spinner.succeed('HedHog file reset successfully.');
+            }
+            catch (error) {
+                spinner.fail('Failed to reset hedhog.json file. Proceeding to reset.');
+                this.log(chalk.red('Error parsing existing hedhog.json file. Proceeding to reset.'));
+            }
+        }
+    }
+    async getRootPath(cwd) {
+        let currentPath = cwd;
+        while (true) {
+            if ((0, fs_1.existsSync)(pathModule.join(currentPath, 'hedhog.json'))) {
+                return currentPath;
+            }
+            const parentPath = pathModule.dirname(currentPath);
+            if (parentPath === currentPath) {
+                throw new Error('Could not find root path with hedhog.json');
+            }
+            currentPath = parentPath;
+        }
+    }
+    async resetDatabase(cwd, spinner) {
+        cwd = await this.getRootPath(cwd);
+        this.log('Resetting database...');
+        spinner.start('Resetting database...');
+        await this.database.executeQuery(pathModule.join(cwd, 'apps', 'api'), 'DROP SCHEMA public CASCADE; CREATE SCHEMA public;');
+        spinner.succeed('Database reset successfully.');
+        this.log('Database reset successfully.');
+    }
+    async removeLibrariesDirectory(cwd, spinner) {
+        this.log('Removing libraries directory...');
+        spinner.start('Removing libraries directory...');
+        const librariesPath = pathModule.join(cwd, 'libraries');
+        if ((0, fs_1.existsSync)(librariesPath)) {
+            // Give Windows time to release file handles
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            await this.fileSystem.remove(librariesPath);
+            this.log('Libraries directory removed.');
+        }
+        spinner.succeed('Libraries directory removed successfully.');
+    }
+    async removeMigrationFiles(cwd, spinner) {
+        this.log('Removing migration files...');
+        spinner.start('Removing migration files...');
+        const migrationsPath = pathModule.join(cwd, 'apps', 'api', 'prisma', 'migrations');
+        if ((0, fs_1.existsSync)(migrationsPath)) {
+            await this.fileSystem.remove(migrationsPath);
+            this.log('Migration files removed.');
+        }
+        spinner.succeed('Migration files removed successfully.');
+    }
+    async resetAppModuleFile(cwd, spinner) {
+        this.log('Reset AppModule.ts file...');
+        spinner.start('Resetting AppModule.ts file...');
+        const appModulePath = pathModule.join(cwd, 'apps', 'api', 'src', 'app.module.ts');
+        if ((0, fs_1.existsSync)(appModulePath)) {
+            let templateContent;
+            this.log(chalk.yellow('Failed to fetch app.module.ts from remote. Using local template.'));
+            const localTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'library', 'init.app.module.ts.ejs');
+            templateContent = await (0, promises_1.readFile)(localTemplatePath, 'utf8');
+            await this.fileSystem.writeFileContent(appModulePath, templateContent);
+            this.log('AppModule.ts file reset.');
+        }
+        spinner.succeed('AppModule.ts file reset successfully.');
+    }
+    async resetPackageJsonFile(cwd, spinner) {
+        this.log('Resetting package.json file...');
+        spinner.start('Resetting package.json file...');
+        const packageJsonPath = pathModule.join(cwd, 'apps', 'api', 'package.json');
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            let templateContent;
+            this.log(chalk.yellow('Failed to fetch package.json from remote. Using local template.'));
+            const localTemplatePath = pathModule.join(__dirname, '..', '..', 'templates', 'library', 'init.package.json.ejs');
+            templateContent = await (0, promises_1.readFile)(localTemplatePath, 'utf8');
+            await this.fileSystem.writeFileContent(packageJsonPath, templateContent);
+            this.log('package.json file reset.');
+        }
+        spinner.succeed('package.json file reset successfully.');
+    }
+    async getRunningDatabaseService(cwd) {
+        try {
+            // Get list of running services
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, ['ps', '--services', '--filter', 'status=running'], { cwd }, true);
+            const services = result.stdout
+                .trim()
+                .split('\n')
+                .filter((s) => s.length > 0);
+            this.log(`Running services: ${services.join(', ')}`);
+            if (services.length === 0) {
+                return null;
+            }
+            // Common database service names
+            const dbServiceNames = [
+                'db',
+                'postgres',
+                'postgresql',
+                'database',
+                'mysql',
+                'mariadb',
+            ];
+            // Try to find a database service
+            for (const dbName of dbServiceNames) {
+                if (services.includes(dbName)) {
+                    this.log(`Found database service: ${dbName}`);
+                    return dbName;
+                }
+            }
+            // If multiple services and no standard name found, ask user to choose
+            if (services.length > 1) {
+                console.log(chalk.yellow('\nMultiple services found. Please select the database service:'));
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'service',
+                        message: 'Which service is your database?',
+                        choices: services,
+                    },
+                ]);
+                return answer.service;
+            }
+            // Only one service, use it
+            this.log(`Using the only available service: ${services[0]}`);
+            return services[0];
+        }
+        catch (error) {
+            this.log(chalk.red('Error getting running services:'), error);
+            return null;
+        }
+    }
+    async backupDatabase(cwd, verbose = false) {
+        this.verbose = verbose;
+        this.log('Backing up database...');
+        const spinner = ora('Backing up database...').start();
+        try {
+            cwd = await this.getRootPath(cwd);
+            // Get database configuration
+            const dbConfig = await this.database.getDatabaseConfig(pathModule.join(cwd, 'apps', 'api'));
+            if (!dbConfig) {
+                throw new Error('Failed to get database configuration');
+            }
+            // Detect running database service
+            spinner.text = 'Detecting database service...';
+            const dbService = await this.getRunningDatabaseService(cwd);
+            if (!dbService) {
+                throw new Error('No running database service found. Please start your database with "docker-compose up -d"');
+            }
+            this.log(`Using database service: ${dbService}`);
+            spinner.text = `Using database service: ${dbService}`;
+            // Create backup directory if it doesn't exist
+            const backupDir = pathModule.join(cwd, 'backup');
+            if (!(0, fs_1.existsSync)(backupDir)) {
+                await (0, promises_1.mkdir)(backupDir, { recursive: true });
+                this.log(`Created backup directory: ${backupDir}`);
+            }
+            // Generate backup filename with timestamp
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupFileName = `backup-${timestamp}.dump`;
+            const backupFile = pathModule.join(backupDir, backupFileName);
+            const containerBackupPath = `/tmp/${backupFileName}`;
+            spinner.text = 'Creating database dump inside container...';
+            this.log(`Creating database dump at: ${backupFile}`);
+            // Execute pg_dump inside the Docker container
+            const dockerExecArgs = [
+                'exec',
+                '-T',
+                dbService,
+                'pg_dump',
+                '-h',
+                'localhost',
+                '-p',
+                '5432',
+                '-U',
+                dbConfig.user,
+                '-d',
+                dbConfig.database,
+                '-F',
+                'c', // custom format
+                '-f',
+                containerBackupPath,
+            ];
+            // Set PGPASSWORD environment variable
+            const env = { ...process.env, PGPASSWORD: dbConfig.password };
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, dockerExecArgs, { cwd, env }, true);
+            spinner.text = 'Copying backup from Docker container to host machine...';
+            this.log('Copying backup from container to host...');
+            // Copy backup file from container to host machine
+            const dockerCpArgs = [
+                'cp',
+                `${dbService}:${containerBackupPath}`,
+                backupFile,
+            ];
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, dockerCpArgs, { cwd }, true);
+            spinner.succeed(`Database backup created successfully at: ${backupFile}`);
+            this.log(chalk.green(`Database backup created successfully at: ${backupFile}`));
+        }
+        catch (error) {
+            spinner.fail('Failed to backup database.');
+            console.error(chalk.red('Error backing up database:'), error);
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    async initDatabase(cwd, verbose = false) {
+        this.verbose = verbose;
+        this.log('Initializing database...');
+        const spinner = ora('Initializing database...').start();
+        try {
+            cwd = await this.getRootPath(cwd);
+            const dockerComposeYmlPath = pathModule.join(cwd, 'docker-compose.yml');
+            const dockerComposeYamlPath = pathModule.join(cwd, 'docker-compose.yaml');
+            const dockerComposeYmlPathExists = (0, fs_1.existsSync)(dockerComposeYmlPath);
+            const dockerComposeYamlPathExists = (0, fs_1.existsSync)(dockerComposeYamlPath);
+            const dockerComposePath = dockerComposeYmlPathExists
+                ? dockerComposeYmlPath
+                : dockerComposeYamlPath;
+            if (!dockerComposeYmlPathExists && !dockerComposeYamlPathExists) {
+                spinner.fail('docker-compose.yml or docker-compose.yaml not found in project root.');
+                throw new Error('docker-compose.yml or docker-compose.yaml not found in project root.');
+            }
+            spinner.text = 'Starting database container using Docker Compose...';
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, ['up', '-d'], { cwd }, true);
+            spinner.succeed('Database container started successfully.');
+            this.log(chalk.green('Database container started successfully.'));
+            spinner.start('Checking database connection...');
+            // Check if .env file exists in the api and admin app directory. If not exists then create it from .env.example and replace variables comparing with env vars in docker-compose
+            await this.database.generateEnvFileIfNotExists(pathModule.join(cwd, 'apps', 'api'), dockerComposePath);
+            spinner.succeed('Environment file checked/created successfully.');
+            this.log(chalk.green('Environment file checked/created successfully.'));
+            spinner.start('Running database migrations...');
+            await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['prisma:deploy'], { cwd: pathModule.join(cwd, 'apps', 'api') }, true);
+            spinner.succeed('Database initialized and migrations applied successfully.');
+            this.log(chalk.green('Database initialized and migrations applied successfully.'));
+            spinner.start('Updating Prisma client...');
+            await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['prisma:update'], { cwd: pathModule.join(cwd, 'apps', 'api') }, true);
+            spinner.succeed('Prisma client updated successfully.');
+            this.log(chalk.green('Prisma client updated successfully.'));
+            spinner.start('Creating .env files for applications...');
+            const appsDir = pathModule.join(cwd, 'apps');
+            if ((0, fs_1.existsSync)(appsDir)) {
+                const appDirs = (0, fs_1.readdirSync)(appsDir, { withFileTypes: true })
+                    .filter((entry) => entry.isDirectory())
+                    .map((entry) => pathModule.join(appsDir, entry.name));
+                for (const appDir of appDirs) {
+                    spinner.text = `Checking .env file for ${appDir}...`;
+                    const envPath = pathModule.join(appDir, '.env');
+                    const envExamplePath = pathModule.join(appDir, '.env.example');
+                    if (!(0, fs_1.existsSync)(envPath) && (0, fs_1.existsSync)(envExamplePath)) {
+                        const envExampleContent = await (0, promises_1.readFile)(envExamplePath, 'utf8');
+                        await (0, promises_1.writeFile)(envPath, envExampleContent, 'utf8');
+                        this.log(chalk.green(`Created .env file for ${appDir}`));
+                    }
+                }
+            }
+            spinner.succeed('.env files created/checked successfully.');
+            this.log(chalk.green('.env files created/checked successfully.'));
+        }
+        catch (error) {
+            spinner.fail('Failed to initialize database.');
+            console.error(chalk.red('Error initializing database:'), error);
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    async restoreDatabase(cwd, verbose = false) {
+        this.verbose = verbose;
+        this.log('Restoring database from backup...');
+        const spinner = ora('Restoring database from backup...').start();
+        try {
+            cwd = await this.getRootPath(cwd);
+            // Get database configuration
+            const dbConfig = await this.database.getDatabaseConfig(pathModule.join(cwd, 'apps', 'api'));
+            if (!dbConfig) {
+                throw new Error('Failed to get database configuration');
+            }
+            // Detect running database service
+            spinner.text = 'Detecting database service...';
+            const dbService = await this.getRunningDatabaseService(cwd);
+            if (!dbService) {
+                throw new Error('No running database service found. Please start your database with "docker-compose up -d"');
+            }
+            this.log(`Using database service: ${dbService}`);
+            // Check backup directory
+            const backupDir = pathModule.join(cwd, 'backup');
+            if (!(0, fs_1.existsSync)(backupDir)) {
+                spinner.fail('Backup directory not found.');
+                throw new Error(`Backup directory not found at: ${backupDir}. Please create a backup first.`);
+            }
+            // List all .dump files in backup directory
+            spinner.text = 'Searching for backup files...';
+            const files = (0, fs_1.readdirSync)(backupDir)
+                .filter((file) => file.endsWith('.dump'))
+                .map((file) => {
+                const filePath = pathModule.join(backupDir, file);
+                const stats = (0, fs_1.statSync)(filePath);
+                return {
+                    name: file,
+                    path: filePath,
+                    mtime: stats.mtime,
+                };
+            })
+                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime()); // Most recent first
+            if (files.length === 0) {
+                spinner.fail('No backup files found.');
+                throw new Error(`No backup files found in: ${backupDir}. Please create a backup first.`);
+            }
+            spinner.stop();
+            // Let user select a backup file
+            console.log(chalk.blue(`\nFound ${files.length} backup file(s):`));
+            const { selectedBackup } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedBackup',
+                    message: 'Select a backup file to restore:',
+                    choices: files.map((file) => ({
+                        name: `${file.name} (${file.mtime.toLocaleString()})`,
+                        value: file.path,
+                    })),
+                },
+            ]);
+            // Check if database has data
+            spinner.start('Checking database for existing data...');
+            let hasData = false;
+            try {
+                const checkResult = await this.database.executeQuery(pathModule.join(cwd, 'apps', 'api'), "SELECT COUNT(*) as table_count FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE';");
+                hasData =
+                    checkResult && parseInt(checkResult[0]?.table_count || '0') > 0;
+                this.log(`Database has data: ${hasData}`);
+            }
+            catch (error) {
+                this.log(chalk.yellow('Could not check for existing data. Proceeding...'));
+            }
+            spinner.stop();
+            // Confirm if database has data
+            if (hasData) {
+                console.log(chalk.yellow('\n⚠️  Warning: The database contains existing data.'));
+                const { confirmRestore } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirmRestore',
+                        message: 'Are you sure you want to replace all existing data with the backup?',
+                        default: false,
+                    },
+                ]);
+                if (!confirmRestore) {
+                    console.log(chalk.blue('Restore operation cancelled.'));
+                    return;
+                }
+            }
+            spinner.start('Copying backup file to container...');
+            this.log(`Restoring from: ${selectedBackup}`);
+            const backupFileName = pathModule.basename(selectedBackup);
+            const containerBackupPath = `/tmp/${backupFileName}`;
+            // Copy backup file from host to container
+            const dockerCpArgs = [
+                'cp',
+                selectedBackup,
+                `${dbService}:${containerBackupPath}`,
+            ];
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, dockerCpArgs, { cwd }, true);
+            spinner.text = 'Dropping and recreating database...';
+            this.log('Dropping and recreating database...');
+            // Drop the database
+            const dropDbArgs = [
+                'exec',
+                '-T',
+                dbService,
+                'dropdb',
+                '-h',
+                'localhost',
+                '-p',
+                '5432',
+                '-U',
+                dbConfig.user,
+                '--if-exists',
+                dbConfig.database,
+            ];
+            const env = { ...process.env, PGPASSWORD: dbConfig.password };
+            try {
+                await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, dropDbArgs, { cwd, env }, true);
+            }
+            catch (error) {
+                // Check if error is due to active connections
+                if (error.message &&
+                    error.message.includes('is being accessed by other users')) {
+                    spinner.fail('Cannot drop database - active connections detected.');
+                    console.log('');
+                    console.log(chalk.yellow('⚠️  Database Connection Error'));
+                    console.log('');
+                    console.log(chalk.white('The database cannot be restored because there are active connections.'));
+                    console.log('');
+                    console.log(chalk.cyan('📋 Please follow these steps:'));
+                    console.log('');
+                    console.log(chalk.white('  1. Close all applications connected to the database:'));
+                    console.log(chalk.gray('     • API servers or backend applications'));
+                    console.log(chalk.gray('     • Database management tools (DBeaver, pgAdmin, etc.)'));
+                    console.log(chalk.gray('     • Any running database queries or scripts'));
+                    console.log('');
+                    console.log(chalk.white('  2. After closing all connections, run this command again'));
+                    console.log('');
+                    console.log(chalk.blue('💡 Tip: You can also restart the database container to force close all connections:'));
+                    console.log(chalk.gray('     docker-compose restart db'));
+                    console.log('');
+                    throw new Error('Database restore cancelled due to active connections');
+                }
+                throw error;
+            }
+            // Create the database
+            const createDbArgs = [
+                'exec',
+                '-T',
+                dbService,
+                'createdb',
+                '-h',
+                'localhost',
+                '-p',
+                '5432',
+                '-U',
+                dbConfig.user,
+                dbConfig.database,
+            ];
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, createDbArgs, { cwd, env }, true);
+            spinner.text = 'Restoring database from backup file...';
+            this.log('Restoring database from backup file...');
+            // Restore database using pg_restore
+            const restoreArgs = [
+                'exec',
+                '-T',
+                dbService,
+                'pg_restore',
+                '-h',
+                'localhost',
+                '-p',
+                '5432',
+                '-U',
+                dbConfig.user,
+                '-d',
+                dbConfig.database,
+                '-v',
+                containerBackupPath,
+            ];
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, restoreArgs, { cwd, env }, true);
+            spinner.text = 'Cleaning up temporary files...';
+            this.log('Cleaning up temporary files...');
+            // Remove temporary backup file from container
+            const cleanupArgs = ['exec', '-T', dbService, 'rm', containerBackupPath];
+            await this.runner.executeCommand(runner_service_1.ProgramName.DOCKER_COMPOSE, cleanupArgs, { cwd }, true);
+            spinner.succeed(chalk.green('Database restored successfully from backup!'));
+            this.log(chalk.green('Database restored successfully from backup!'));
+        }
+        catch (error) {
+            spinner.fail('Failed to restore database.');
+            // Only show detailed error if it's not the active connections error
+            if (!error.message ||
+                !error.message.includes('Database restore cancelled due to active connections')) {
+                console.error(chalk.red('Error restoring database:'), error);
+            }
+            throw error;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+};
+exports.DeveloperService = DeveloperService;
+exports.DeveloperService = DeveloperService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [runner_service_1.RunnerService,
+        file_system_service_1.FileSystemService,
+        database_service_1.DatabaseService])
+], DeveloperService);
+//# sourceMappingURL=developer.service.js.map