Caching Strategy Patterns

// domain/repository/i_schedule_repository.dart
abstract interface class IScheduleRepository {
  /// Returns Stream using SWR strategy
  Stream<Either<Failure, List<ScheduleDayData>>> getScheduleData({
    required DateTime startDate,
    required DateTime endDate,
    String? classId,
  });
}

mixin ScheduleOpenApiMixin implements IScheduleRepository {
  OpenApiService get openApiService;
  ScheduleItemDao get scheduleItemDao;

  @override
  Stream<Either<Failure, List<ScheduleDayData>>> getScheduleData({
    required DateTime startDate,
    required DateTime endDate,
    String? classId,
  }) =>
      SwrStrategyImpl<List<ScheduleDayData>>(
        cacheRepository: ScheduleDataCacheRepository(
          scheduleItemDao: scheduleItemDao,
        ),
        networkRepository: ScheduleDataNetworkRepository(
          openApiService: openApiService,
        ),
        policy: CachePolicies.standard,
      ).watchStream(
        ScheduleDataCacheQuery(
          startDate: startDate,
          endDate: endDate,
          classId: classId,
        ),
      );
}

class ScheduleBloc extends BlocSignal<ScheduleEvent, ScheduleState> {
  ScheduleBloc() : super(initialState: const ScheduleState()) {
    on<_LoadData>(_onLoadData, transformer: restartable());
  }

  StreamSubscription<Either<Failure, ScheduleData>>? _dataSub;

  Future<void> _onLoadData(
    _LoadData event,
    void Function(ScheduleState) emit,
  ) async {
    await _dataSub?.cancel();

    _dataSub = const GetScheduleDataUseCase().call(
      GetScheduleDataParams(
        startDate: event.startDate,
        endDate: event.endDate,
      ),
    ).listen(
      (result) {
        if (isClosed) return;
        emit(result.fold(
          (failure) => stateValue.copyWith(status: Status.failure),
          (data)    => stateValue.copyWith(status: Status.success, data: data),
        ));
      },
      onError: (Object _, StackTrace __) {
        if (isClosed) return;
        emit(stateValue.copyWith(status: Status.failure));
      },
    );
  }

  @override
  Future<void> close() async {
    if (isClosed) return;
    await _dataSub?.cancel(); // ⚠️ 자동 정리 없음
    await super.close();
  }
}

1. add(LoadData(start: mar1))  → 스트림A 구독 (캐시 → 서버 순차 emit)
2. add(LoadData(start: apr1))  → 핸들러가 _dataSub.cancel() 로 스트림A 해제
                                  → 스트림B 구독 시작
                                  → restartable() 은 핸들러1 의 늦은 emission 을 폐기

@override
Future<Either<Failure, ScheduleMemo?>> getMemo({
  required DateTime date,
}) =>
    CacheFirstStrategyImpl<ScheduleMemo?>(
      cacheRepository: ScheduleMemoCacheRepository(
        memoCacheDao: memoCacheDao,
      ),
      networkRepository: ScheduleMemoNetworkRepository(
        openApiService: openApiService,
      ),
      policy: CachePolicies.standard,
    ).execute(
      ScheduleMemoCacheQuery(date: date),
    );

Future<void> _onDetailLoaded(
  _DetailLoaded event,
  void Function(ScheduleState) emit,
) async {
  emit(stateValue.copyWith(detailStatus: Status.loading));
  final result = await const GetMemoUseCase().call(
    GetMemoParams(date: event.date),
  );
  if (isClosed) return;  // Required
  result.fold(
    (failure) => emit(stateValue.copyWith(detailStatus: Status.failure)),
    (memo)    => emit(stateValue.copyWith(detailStatus: Status.success, memo: memo)),
  );
}

@override
Future<Either<Failure, PaymentStatus>> getPaymentStatus({
  required String orderId,
}) =>
    NetworkFirstStrategyImpl<PaymentStatus>(
      cacheRepository: PaymentStatusCacheRepository(
        paymentStatusDao: paymentStatusDao,
      ),
      networkRepository: PaymentStatusNetworkRepository(
        openApiService: openApiService,
      ),
      policy: CachePolicies.realtime,
    ).execute(
      PaymentStatusCacheQuery(orderId: orderId),
    );

@DataClassName('ScheduleItemData')
class ScheduleItems extends Table {
  TextColumn get cacheKey => text()();          // Required
  DateTimeColumn get date => dateTime()();      // Parent field
  TextColumn get id => text()();
  TextColumn get title => text()();
  DateTimeColumn get cachedAt => dateTime()();  // Required
  // No primaryKey (use rowid)
}

// DELETE(cacheKey) + INSERT (upsert prohibited)
Future<void> saveItems(
  List<ScheduleItemsCompanion> companions,
  String cacheKey,
) async {
  await (delete(scheduleItems)
        ..where((t) => t.cacheKey.equals(cacheKey)))
      .go();
  await batch((b) => b.insertAll(scheduleItems, companions));
}

// Cache invalidation (prefix matching)
// ⚠️ Do NOT use like('$prefix%') — `_` in cache keys is a single-char LIKE
// wildcard, so 'my_page__' would also delete 'myxpage__…' keys (#8334).
// Use a string range comparison for exact prefix semantics:
Future<void> deleteByCacheKeyPrefix(String prefix) =>
    (delete(scheduleItems)..where(
          (t) =>
              t.cacheKey.isBiggerOrEqualValue(prefix) &
              t.cacheKey.isSmallerThanValue('$prefix\uffff'),
        ))
        .go();

HTTP Method?
├── GET
│   ├── Response is list  →  SWR
│   └── Response is single
│       ├── Offline first  →  CacheFirst
│       └── Always latest  →  NetworkFirst
└── POST/PUT/DELETE
    → Direct call + deleteByCacheKeyPrefix()