feat(core): clean up providers during shutdown and enable transaction context propagation

.gitignore

@@ -1 +1 @@
-.dart_tool/
+.dart_tool/

open-feature-dart-server-sdk/lib/client.dart

@@ -102,7 +102,7 @@ class FeatureClient {
         HookStage.ERROR,
         flagKey,
         currentContext,
-        error: error,
+        error: error, 
       );
       return defaultValue;
     } finally {

open-feature-dart-server-sdk/lib/open_feature_api.dart

@@ -4,6 +4,9 @@ import 'domain_manager.dart'; // Required for @visibleForTesting
 import 'feature_provider.dart';
 import 'package:meta/meta.dart';
 
+import 'transaction_context.dart';
+
+
 // Define OpenFeatureEventType to represent different event types.
 enum OpenFeatureEventType {
   providerChanged,
@@ -17,19 +20,23 @@ class OpenFeatureEvent {
   final OpenFeatureEventType type;
   final String message;
   final dynamic data;
-
   OpenFeatureEvent(this.type, this.message, {this.data});
 }
 
-
-
-
 /// Abstract OpenFeatureProvider interface for extensibility
 abstract class OpenFeatureProvider {
   static final Logger _logger = Logger('OpenFeatureProvider');
 
   String get name;
 
+
+
+  // Shutdown method for cleaning up resources.
+  Future<void> shutdown() async {
+    _logger.info('Shutting down provider: $name');
+    // Default implementation does nothing.
+  }
+
   // Generic method to get a feature flag's value
   Future<dynamic> getFlag(String flagKey, {Map<String, dynamic>? context});
 }
@@ -43,21 +50,35 @@ class OpenFeatureNoOpProvider implements OpenFeatureProvider {
   Future<dynamic> getFlag(String flagKey,
       {Map<String, dynamic>? context}) async {
 
+    OpenFeatureProvider._logger
+        .info('Returning default value for flag: $flagKey');
+
     return null; // Return null or default values for flags.
+  }
 
+  // Implement the shutdown method (even if it does nothing).
+  @override
+  Future<void> shutdown() async {
+    // No-op shutdown implementation (does nothing).
+    OpenFeatureProvider._logger.info('Shutting down provider: $name');
 
   }
 }
 
 /// Global evaluation context shared across feature evaluations
 class OpenFeatureEvaluationContext {
   final Map<String, dynamic> attributes;
+  TransactionContext?
+      transactionContext; // Optional, for transaction-specific data
 
-  OpenFeatureEvaluationContext(this.attributes);
+  OpenFeatureEvaluationContext(this.attributes, {this.transactionContext});
 
   /// Merge this context with another context
   OpenFeatureEvaluationContext merge(OpenFeatureEvaluationContext other) {
-    return OpenFeatureEvaluationContext({...attributes, ...other.attributes});
+    return OpenFeatureEvaluationContext(
+      {...attributes, ...other.attributes},
+      transactionContext: other.transactionContext ?? this.transactionContext,
+    );
   }
 }
 
@@ -125,6 +146,9 @@ class OpenFeatureAPI {
   // Domain manager to manage client-provider bindings
   final DomainManager _domainManager = DomainManager();
 
+  // Stack to manage transaction contexts
+  final List<TransactionContext> _transactionContextStack = [];
+
 
   // Extension management
   final Map<String, ExtensionConfig> _extensions = {};
@@ -165,18 +189,16 @@ class OpenFeatureAPI {
   void dispose() {
     _logger.info('Disposing OpenFeatureAPI resources.');
     _providerStreamController.close();
-   _eventStreamController.close();
+  _eventStreamController.close();
 
     _extensionEventController.close();
-
   }
 
   // Original API methods
   void setProvider(OpenFeatureProvider provider) {
     _logger.info('Provider is being set to: ${provider.name}');
     _provider = provider;
 
-
     // Emit provider update
     _providerStreamController.add(provider);
 
@@ -207,6 +229,14 @@ class OpenFeatureAPI {
     _hooks.addAll(hooks);
   }
 
+  /// Reset the singleton instance for testing purposes.
+  ///
+  /// This ensures a clean state for each test case.
+  @visibleForTesting
+  static void resetInstance() {
+    _instance?.dispose();
+    _instance = null;
+  }
 
   /// Emit an event to the event stream.
   void _emitEvent(OpenFeatureEvent event) {
@@ -232,14 +262,10 @@ class OpenFeatureAPI {
   Stream<OpenFeatureProvider> get providerUpdates =>
       _providerStreamController.stream;
 
-
-
   // New extension-related methods
   Future<void> registerExtension(
+      String extensionId, ExtensionConfig config) async {
 
-
-
-    String extensionId, ExtensionConfig config) async {
     _logger.info('Registering extension: $extensionId');
 
     // Validate dependencies
@@ -266,21 +292,18 @@ class OpenFeatureAPI {
       extensionId: extensionId,
       type: 'REGISTRATION',
       status: 'UNREGISTERED',
-    ));
-  }
+    ));  }
 
   T? getExtension<T>(String extensionId) {
     return _extensionInstances[extensionId] as T?;
   }
-
   List<String> getRegisteredExtensions() {
     return List.unmodifiable(_extensions.keys);
   }
 
   Stream<ExtensionEvent> get extensionEvents =>
       _extensionEventController.stream;
 
-
   Future<bool> evaluateBooleanFlag(String flagKey, String clientId,
       {Map<String, dynamic>? context}) async {
     // Get provider for the client
@@ -289,7 +312,6 @@ class OpenFeatureAPI {
       _logger.info('Using provider $providerName for client $clientId');
       _runBeforeEvaluationHooks(flagKey, context);
 
-
       try {
         final result = await _provider.getFlag(flagKey, context: context);
 
@@ -349,7 +371,40 @@ class OpenFeatureAPI {
 
   /// Streams for listening to events and provider updates.
   Stream<OpenFeatureEvent> get events => _eventStreamController.stream;
-
+
+  // **Shutdown**: Gracefully clean up the provider during shutdown
+  Future<void> shutdown() async {
+    _logger.info('Shutting down OpenFeatureAPI...');
+    await _provider.shutdown(); // Shutdown the provider
+    // Optionally, cleanup transaction contexts
+
+    _transactionContextStack.clear();
+    dispose();
+  }
+
+  // **Transaction Context Propagation**: Set a specific evaluation context for a transaction
+  void pushTransactionContext(TransactionContext context) {
+    _transactionContextStack.add(context);
+    _logger.info('Pushed new transaction context: ${context.id}');
+  }
+
+  TransactionContext? popTransactionContext() {
+    if (_transactionContextStack.isNotEmpty) {
+      final context = _transactionContextStack.removeLast();
+      _logger.info('Popped transaction context: ${context.id}');
+      return context;
+    } else {
+      _logger.warning('No transaction context to pop');
+      return null;
+    }
+  }
+
+  TransactionContext? get currentTransactionContext {
+    return _transactionContextStack.isNotEmpty
+        ? _transactionContextStack.last
+        : null;
+  }
+
 }
 
 // Dependency Injection for managing the singleton lifecycle

open-feature-dart-server-sdk/lib/transaction_context.dart

@@ -0,0 +1,26 @@
+class TransactionContext {
+  final String id; // Unique identifier for the transaction context
+  final Map<String, dynamic> attributes;
+
+  TransactionContext(this.id, this.attributes);
+
+  /// Merge this context with another context
+  TransactionContext merge(TransactionContext other) {
+    return TransactionContext(id, {...attributes, ...other.attributes});
+  }
+
+  /// Get a specific attribute from the context
+  dynamic get(String key) {
+    return attributes[key];
+  }
+
+  /// Set an attribute in the context
+  void set(String key, dynamic value) {
+    attributes[key] = value;
+  }
+
+  /// Clear all attributes (for transaction completion)
+  void clear() {
+    attributes.clear();
+  }
+}

open-feature-dart-server-sdk/test/domain_manager_test.dart

@@ -0,0 +1,31 @@
+import 'package:open_feature_dart_server_sdk/domain_manager.dart';
+import 'package:test/test.dart';
+// Update with the correct path
+
+void main() {
+  group('DomainManager', () {
+    DomainManager? domainManager;
+
+    setUp(() {
+      domainManager = DomainManager();
+    });
+
+    test('should bind a client to a provider', () {
+      domainManager!.bindClientToProvider('client1', 'providerA');
+      final providerName = domainManager!.getProviderForClient('client1');
+      expect(providerName, equals('providerA'));
+    });
+
+    test('should return null for unbound client', () {
+      final providerName = domainManager!.getProviderForClient('client2');
+      expect(providerName, isNull);
+    });
+
+    test('should update provider binding for a client', () {
+      domainManager!.bindClientToProvider('client1', 'providerA');
+      domainManager!.bindClientToProvider('client1', 'providerB');
+      final providerName = domainManager!.getProviderForClient('client1');
+      expect(providerName, equals('providerB'));
+    });
+  });
+}