evaluateBooleanFlag method

Future<bool> evaluateBooleanFlag(String flagKey, String clientId, { Map<String, dynamic>? context, })

Implementation

Future<bool> evaluateBooleanFlag(
  String flagKey,
  String clientId, {
  Map<String, dynamic>? context,
}) async {
  final providerId = _domainManager.getProviderForClient(clientId);
  if (providerId == null) {
    _logger.warning('No provider found for client $clientId');
    return false;
  }

  // Per OpenFeature spec: short-circuit if provider not READY
  if (_provider.state != ProviderState.READY) {
    _logger.warning(
      'Provider not ready for evaluation (state: ${_provider.state})',
    );
    _emitEvent(
      OpenFeatureEventType.error,
      'Flag evaluation attempted on non-ready provider',
      data: {'flagKey': flagKey, 'providerState': _provider.state.name},
    );
    return false;
  }

  try {
    _runBeforeEvaluationHooks(flagKey, context);



    final result = await _provider.getBooleanFlag(
      flagKey,
      false,
      context: context,
    );

    _emitEvent(
      OpenFeatureEventType.flagEvaluated,
      'Flag $flagKey evaluated for client $clientId',
      data: {
        'result': result.value,
        'context': context,
        'errorCode': result.errorCode?.name,
      },
    );

    _runAfterEvaluationHooks(flagKey, result.value, context);

    if (result.errorCode != null) {
      _logger.warning('Flag evaluation error: ${result.errorMessage}');
      _emitEvent(
        OpenFeatureEventType.error,
        'Error evaluating flag $flagKey',
        data: {
          'errorCode': result.errorCode?.name,
          'errorMessage': result.errorMessage,
        },
      );
    }

    return result.value;
  } catch (error) {
    _logger.warning('Error evaluating flag $flagKey: $error');
    _emitEvent(
      OpenFeatureEventType.error,
      'Error evaluating flag $flagKey',
      data: error,
    );
    return false;
  }
}