Recipe 1 — Flutter Weather

$ mkdir flutter_weather && cd flutter_weather
$ flutist init
▶ Do you want to create a new Flutter project? (y/n): y

$ flutist pub add equatable bloc flutter_bloc hydrated_bloc json_annotation http google_fonts

$ flutist create --name weather --path features --options clean

✓ features/weather/weather_domain 생성
✓ features/weather/weather_data 생성
✓ features/weather/weather_presentation 생성
✓ project.dart 업데이트
✓ flutist_gen.dart 재생성

final project = Project(
  name: 'flutter_weather',
  options: const ProjectOptions(compositionRoots: ['app']),
  modules: [

    // ── Domain: 순수 비즈니스 로직, 외부 의존 없음 ─────────
    Module(
      name: 'weather_domain',
      dependencies: [package.dependencies.equatable],
      devDependencies: [package.dependencies.test],
    ),

    // ── Data: Open Meteo API 클라이언트 ────────────────────
    Module(
      name: 'weather_data',
      dependencies: [
        package.dependencies.http,
        package.dependencies.jsonAnnotation,
      ],
      devDependencies: [
        package.dependencies.test,
        package.dependencies.mocktail,
      ],
      modules: [package.modules.weatherDomain],
    ),

    // ── Presentation: WeatherCubit, ThemeCubit ─────────────
    Module(
      name: 'weather_presentation',
      dependencies: [
        package.dependencies.flutterBloc,
        package.dependencies.hydratedBloc,
        package.dependencies.googleFonts,
      ],
      devDependencies: [
        package.dependencies.blocTest,
        package.dependencies.mocktail,
      ],
      modules: [package.modules.weatherDomain],   // domain만 의존
    ),

    // ── App: composition root — data 구현체 주입 ───────────
    Module(
      name: 'app',
      modules: [
        package.modules.weatherPresentation,
        package.modules.weatherData,   // ✅ composition root만 구현체 참조 가능
      ],
    ),
  ],
);

import 'package:equatable/equatable.dart';

enum TemperatureUnits { fahrenheit, celsius }

class Temperature extends Equatable {
  const Temperature({required this.value});
  final double value;

  @override
  List<Object> get props => [value];
}

class Weather extends Equatable {
  const Weather({
    required this.condition,
    required this.location,
    required this.temperature,
    required this.lastUpdated,
  });

  final WeatherCondition condition;
  final String location;
  final Temperature temperature;
  final DateTime lastUpdated;

  @override
  List<Object> get props => [condition, location, temperature, lastUpdated];
}

enum WeatherCondition { clear, rainy, cloudy, snowy, unknown }

import 'weather.dart';

abstract interface class WeatherRepository {
  /// 도시명으로 날씨 조회. Data 레이어가 구현한다.
  Future<Weather> getWeather(String city);
}

import 'package:http/http.dart' as http;
import 'package:weather_domain/weather_domain.dart';
import 'dart:convert';

class WeatherRepositoryImpl implements WeatherRepository {
  const WeatherRepositoryImpl({http.Client? httpClient})
      : _httpClient = httpClient ?? const http.Client();

  final http.Client _httpClient;

  @override
  Future<Weather> getWeather(String city) async {
    // 1. Geocoding: 도시명 → 위경도
    final geoRes = await _httpClient.get(
      Uri.https('geocoding-api.open-meteo.com', '/v1/search', {'name': city, 'count': '1'}),
    );
    final geoJson = jsonDecode(geoRes.body) as Map<String, dynamic>;
    final results = geoJson['results'] as List?;
    if (results == null || results.isEmpty) throw Exception('City not found');

    final location = results[0];
    final lat = location['latitude'] as double;
    final lng = location['longitude'] as double;

    // 2. Forecast: 위경도 → 현재 날씨
    final wRes = await _httpClient.get(
      Uri.https('api.open-meteo.com', '/v1/forecast', {
        'latitude': '$lat', 'longitude': '$lng',
        'current_weather': 'true',
      }),
    );
    final wJson = jsonDecode(wRes.body) as Map<String, dynamic>;
    final current = wJson['current_weather'] as Map<String, dynamic>;

    return Weather(
      location: location['name'] as String,
      temperature: Temperature(value: (current['temperature'] as num).toDouble()),
      condition: _codeToCondition(current['weathercode'] as int),
      lastUpdated: DateTime.now(),
    );
  }

  WeatherCondition _codeToCondition(int code) {
    if (code == 0) return WeatherCondition.clear;
    if (code <= 3) return WeatherCondition.cloudy;
    if (code <= 67) return WeatherCondition.rainy;
    if (code <= 77) return WeatherCondition.snowy;
    return WeatherCondition.unknown;
  }
}

import 'package:hydrated_bloc/hydrated_bloc.dart';
import 'package:weather_domain/weather_domain.dart';

part 'weather_state.dart';

class WeatherCubit extends HydratedCubit<WeatherState> {
  WeatherCubit(this._weatherRepository) : super(WeatherState());

  final WeatherRepository _weatherRepository;  // interface만 알고 있음

  Future<void> fetchWeather(String city) async {
    if (city.isEmpty) return;
    emit(state.copyWith(status: WeatherStatus.loading));
    try {
      final weather = await _weatherRepository.getWeather(city);
      emit(state.copyWith(status: WeatherStatus.success, weather: weather));
    } catch (_) {
      emit(state.copyWith(status: WeatherStatus.failure));
    }
  }

  void toggleUnits() {
    final units = state.temperatureUnits == TemperatureUnits.fahrenheit
        ? TemperatureUnits.celsius
        : TemperatureUnits.fahrenheit;
    emit(state.copyWith(temperatureUnits: units));
  }

  @override
  WeatherState fromJson(Map<String, dynamic> json) =>
      WeatherState.fromJson(json);

  @override
  Map<String, dynamic> toJson(WeatherState state) => state.toJson();
}

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:hydrated_bloc/hydrated_bloc.dart';
import 'package:path_provider/path_provider.dart';
import 'package:weather_data/weather_data.dart';          // ✅ 구현체
import 'package:weather_presentation/weather_presentation.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  HydratedBloc.storage = await HydratedStorage.build(
    storageDirectory: await getApplicationDocumentsDirectory(),
  );
  runApp(const App());
}

class App extends StatelessWidget {
  const App({super.key});

  @override
  Widget build(BuildContext context) {
    return RepositoryProvider(
      create: (_) => WeatherRepositoryImpl(),   // 구현체 주입
      child: BlocProvider(
        create: (ctx) => WeatherCubit(ctx.read<WeatherRepositoryImpl>()),
        child: const WeatherAppView(),
      ),
    );
  }
}

$ flutist generate

✓ [Clean] weather_data → weather_domain: OK (data → domain)
✓ [Clean] weather_presentation → weather_domain: OK (presentation → domain)
✗ weather_domain → weather_data: 역방향 의존성 — generate 중단!
   → weather_domain에서 http import를 제거하세요

$ flutist generate   # 수정 후
✓ 모든 아키텍처 규칙 통과
✓ pubspec.yaml 4개 동기화 완료