execute method

Future<void> execute()

Implementation

Future<void> execute() async {
  final snakeFeatureName = StringUtils.toSnakeCase(featureName);
  final snakePageName = StringUtils.toSnakeCase(pageName);
  final pascalPageName = StringUtils.toPascalCase(pageName);
  final camelPageName = StringUtils.toCamelCase(pageName);

  // Check if running from project root
  final currentDir = Directory.current.path;
  final melosFile = File('$currentDir/melos.yaml');
  final packagesDir = Directory('$currentDir/packages');

  if (!melosFile.existsSync() || !packagesDir.existsSync()) {
    Logger.error(
        '❌ Please run this command from the project root directory!');
    Logger.error(
        '   (The directory containing melos.yaml and packages/ folder)');
    print('');
    print('Current directory: $_cyan$currentDir$_reset');
    print('Expected files: ${_cyan}melos.yaml, packages/$_reset');
    exit(1);
  }

  Logger.header(
      'Creating Page: $snakePageName in feature: $snakeFeatureName');

  // Determine packages path
  final packagesPath =
      currentDir.endsWith('packages') ? currentDir : '$currentDir/packages';

  final featurePath = '$packagesPath/features_$snakeFeatureName';

  // Check if feature exists
  if (!Directory(featurePath).existsSync()) {
    Logger.error('❌ Feature "features_$snakeFeatureName" does not exist!');
    print('');
    print('${_yellow}Available features:$_reset');
    final features = packagesDir
        .listSync()
        .whereType<Directory>()
        .where((d) => d.path.split('/').last.startsWith('features_'))
        .toList();

    if (features.isEmpty) {
      print('$_yellow  No features found. Create one with:$_reset');
      print('  ${_cyan}maloc feature <feature-name>$_reset');
    } else {
      for (var feature in features) {
        print('$_yellow  • ${feature.path.split('/').last}$_reset');
      }
    }
    exit(1);
  }

  final pagesPath = '$featurePath/lib/presentation/pages';
  final pageFile = '$pagesPath/${snakePageName}_page.dart';

  // Check if page already exists
  if (File(pageFile).existsSync()) {
    Logger.error('❌ Page "${snakePageName}_page.dart" already exists!');
    exit(1);
  }

  try {
    // Create pages directory if it doesn't exist
    Directory(pagesPath).createSync(recursive: true);

    // Generate BLoC files if requested
    if (withBloc) {
      Logger.step('Generating BLoC files...');
      _generateBlocFiles(
          featurePath, snakePageName, pascalPageName, camelPageName);
      Logger.success('Generated BLoC files');
    }

    // Generate data and domain layers if requested
    if (withData) {
      Logger.step('Generating domain layer...');
      _generateDomainLayer(
          featurePath, snakePageName, pascalPageName, camelPageName);
      Logger.success('Generated domain layer');

      Logger.step('Generating data layer...');
      _generateDataLayer(
          featurePath, snakePageName, pascalPageName, camelPageName);
      Logger.success('Generated data layer');
    }

    // Generate page content
    Logger.step('Generating page...');
    final pageContent = withBloc
        ? PageGenerator.generate(snakePageName, pascalPageName, camelPageName,
            withData: withData)
        : _generatePageContent(snakePageName, pascalPageName, camelPageName);
    _writeFile(pageFile, pageContent);
    Logger.success('Generated ${snakePageName}_page.dart');

    // Update barrel export file
    Logger.step('Updating barrel export...');
    _updateBarrelExports(featurePath, snakePageName, snakeFeatureName);
    Logger.success('Updated features_$snakeFeatureName.dart');

    // Add route to app_routes.dart
    Logger.step('Adding route to app_routes.dart...');
    _addRouteToAppRoutes(snakePageName, pascalPageName, camelPageName);
    Logger.success('Route added to app_routes.dart');

    // Register route in app_router.dart
    Logger.step('Registering route in app_router.dart...');
    _registerRouteInAppRouter(
        snakePageName, pascalPageName, camelPageName, snakeFeatureName);
    Logger.success('Route registered in app_router.dart');

    // Register in dependency injection
    if (withBloc) {
      Logger.step('Registering in dependency injection...');
      _registerInDI(snakePageName, pascalPageName, withData);
      Logger.success('Registered in injection_container.dart');
    }

    Logger.header('Page Created Successfully! 🎉');
    print('');
    print('$_green✨ What was generated:$_reset');
    print('   • Page: ${snakePageName}_page.dart');
    if (withBloc) {
      print('   • BLoC: ${snakePageName}_bloc.dart');
      print('   • Events: ${snakePageName}_event.dart');
      print('   • States: ${snakePageName}_state.dart');
    }
    if (withData) {
      print('   • Entity: ${snakePageName}_entity.dart');
      print('   • Repository: ${snakePageName}_repository.dart');
      print('   • Use Case: get_${snakePageName}_usecase.dart');
      print('   • Model: ${snakePageName}_model.dart');
      print('   • DataSource: ${snakePageName}_remote_datasource.dart');
      print(
          '   • Repository Implementation: ${snakePageName}_repository_impl.dart');
    }
    print('   • Route: AppRoutes.${camelPageName}Path = \'/$snakePageName\'');
    if (withBloc) {
      print('   • Dependency Injection: ${pascalPageName}Bloc registered');
    }
    print('');
    print('$_green✨ What was done automatically:$_reset');
    print('   • Added route to app_routes.dart');
    print('   • Registered GoRoute in app_router.dart');
    if (withBloc) {
      print('   • Registered dependencies in injection_container.dart');
    }
    print('');
    print('$_yellow🚀 Ready to use!$_reset');
    print(
        '   Navigate with: ${_cyan}AppRoutes.navigateTo$pascalPageName(context)$_reset');
    print('');
  } catch (e) {
    Logger.error('Error creating page: $e');
    exit(1);
  }
}