🎨 added new core classes

packages/clean_framework/lib/clean_framework_providers.dart

@@ -1,6 +1,8 @@
 /// Clean Framework Providers
 library clean_framework_providers;
 
+export 'package:clean_framework/src/core/external_interface/request.dart';
+export 'package:clean_framework/src/core/external_interface/response.dart';
 export 'package:clean_framework/src/providers/bridge_gateway_provider.dart';
 export 'package:clean_framework/src/providers/entity.dart';
 export 'package:clean_framework/src/providers/external_interface.dart';
@@ -10,8 +12,5 @@ export 'package:clean_framework/src/providers/gateway_provider.dart';
 export 'package:clean_framework/src/providers/presenter.dart';
 export 'package:clean_framework/src/providers/ui.dart';
 export 'package:clean_framework/src/providers/use_case.dart';
-export 'package:clean_framework/src/providers/use_case.dart';
-export 'package:clean_framework/src/providers/use_case_provider.dart';
 export 'package:clean_framework/src/providers/use_case_provider.dart';
 export 'package:clean_framework/src/providers/view_model.dart';
-export 'package:clean_framework/src/providers/view_model.dart';

packages/clean_framework/lib/src/core/clean_framework_provider.dart

@@ -0,0 +1,9 @@
+import 'package:riverpod/riverpod.dart';
+
+abstract class CleanFrameworkProvider<P extends ProviderBase<Object>> {
+  CleanFrameworkProvider({required P provider}) : _provider = provider;
+
+  final P _provider;
+
+  P call() => _provider;
+}

packages/clean_framework/lib/src/core/external_interface/external_interface.dart

@@ -0,0 +1,123 @@
+import 'dart:async';
+
+import 'package:clean_framework/src/core/external_interface/request.dart';
+import 'package:clean_framework/src/core/external_interface/response.dart';
+import 'package:clean_framework/src/core/gateway/gateway.dart';
+import 'package:clean_framework/src/core/gateway/gateway_provider.dart';
+import 'package:clean_framework/src/utilities/either.dart';
+import 'package:meta/meta.dart';
+import 'package:riverpod/riverpod.dart';
+
+abstract class ExternalInterface<R extends Request, S extends SuccessResponse> {
+  ExternalInterface() {
+    handleRequest();
+  }
+
+  @internal
+  void attach(
+    ProviderRef<Object> ref, {
+    required List<GatewayProvider> providers,
+  }) {
+    for (final gatewayProvider in providers) {
+      _initTransporter(ref.read(gatewayProvider()));
+    }
+  }
+
+  void _initTransporter(Gateway gateway) {
+    // ignore: invalid_use_of_visible_for_testing_member
+    gateway.feedResponse(
+      (request) async {
+        final req = request as R;
+        final requestCompleter = gateway is WatcherGateway
+            ? _StreamRequestCompleter<R, S>(req, gateway.yieldResponse)
+            : _RequestCompleter<R, S>(req);
+
+        _requestController.add(requestCompleter);
+        return requestCompleter.future;
+      },
+    );
+  }
+
+  final _RequestController<R, S> _requestController =
+      StreamController.broadcast();
+
+  void handleRequest();
+
+  FailureResponse onError(Object error);
+
+  void on<E extends R>(
+    RequestHandler<E, S> handler,
+  ) {
+    _requestController.stream.where((e) => e.request is E).listen(
+      (e) async {
+        final request = e.request as E;
+
+        try {
+          if (e is _StreamRequestCompleter) {
+            final event = e as _StreamRequestCompleter<R, S>;
+            final handlerCall = handler(
+              request,
+              (response) {
+                if (!event.isCompleted) event.complete(response);
+                event.emitSuccess(response);
+              },
+            );
+
+            if (handlerCall is Future) {
+              unawaited(
+                handlerCall.catchError(
+                  (Object error) => e.completeFailure(_onError(error, request)),
+                ),
+              );
+            }
+          } else {
+            await handler(request, e.complete);
+          }
+        } catch (error) {
+          e.completeFailure(_onError(error, request));
+        }
+      },
+    );
+  }
+
+  Never sendError(Object error) => throw error;
+
+  FailureResponse _onError(Object error, R request) {
+    //CleanFrameworkObserver.instance.onExternalError(this, request, error);
+    final failure = onError(error);
+    //CleanFrameworkObserver.instance.onFailureResponse(this, request, failure);
+    return failure;
+  }
+}
+
+typedef _RequestController<R extends Request, S extends SuccessResponse>
+    = StreamController<_RequestCompleter<R, S>>;
+
+typedef ResponseSender<S extends SuccessResponse> = void Function(S response);
+
+typedef RequestHandler<E extends Request, S extends SuccessResponse>
+    = FutureOr<void> Function(E request, ResponseSender<S> send);
+
+class _RequestCompleter<R extends Request, S extends SuccessResponse> {
+  _RequestCompleter(this.request) : _completer = Completer();
+
+  final R request;
+  final Completer<Either<FailureResponse, S>> _completer;
+
+  Future<Either<FailureResponse, S>> get future => _completer.future;
+
+  bool get isCompleted => _completer.isCompleted;
+
+  void complete(S success) => _completer.complete(Either.right(success));
+
+  void completeFailure(FailureResponse failure) {
+    _completer.complete(Either.left(failure));
+  }
+}
+
+class _StreamRequestCompleter<R extends Request, S extends SuccessResponse>
+    extends _RequestCompleter<R, S> {
+  _StreamRequestCompleter(super.request, this.emitSuccess);
+
+  final void Function(S) emitSuccess;
+}

packages/clean_framework/lib/src/core/external_interface/external_interface_provider.dart

@@ -0,0 +1,20 @@
+import 'package:clean_framework/src/core/clean_framework_provider.dart';
+import 'package:clean_framework/src/core/external_interface/external_interface.dart';
+import 'package:clean_framework/src/core/gateway/gateway_provider.dart';
+import 'package:meta/meta.dart';
+import 'package:riverpod/riverpod.dart';
+
+class ExternalInterfaceProvider<E extends ExternalInterface>
+    extends CleanFrameworkProvider<Provider<E>> {
+  ExternalInterfaceProvider(
+    E Function() create, {
+    List<GatewayProvider> gateways = const [],
+  }) : super(
+          provider: Provider(
+            (ref) => create()..attach(ref, providers: gateways),
+          ),
+        );
+
+  @visibleForTesting
+  E read(ProviderContainer container) => container.read(call());
+}

packages/clean_framework/lib/src/core/external_interface/request.dart

@@ -0,0 +1,6 @@
+import 'package:meta/meta.dart';
+
+@immutable
+abstract class Request {
+  const Request();
+}

packages/clean_framework/lib/src/core/external_interface/response.dart

@@ -0,0 +1,43 @@
+import 'package:equatable/equatable.dart';
+import 'package:meta/meta.dart';
+
+@immutable
+abstract class Response extends Equatable {
+  const Response();
+  @override
+  bool get stringify => true;
+}
+
+class SuccessResponse extends Response {
+  const SuccessResponse();
+
+  @override
+  List<Object?> get props => [];
+}
+
+abstract class FailureResponse extends Response {
+  const FailureResponse({this.message = ''});
+
+  final String message;
+
+  @override
+  List<Object?> get props => [message];
+}
+
+class TypedFailureResponse<T extends Object> extends FailureResponse {
+  const TypedFailureResponse({
+    required this.type,
+    this.errorData = const {},
+    super.message,
+  });
+
+  final T type;
+  final Map<String, Object?> errorData;
+
+  @override
+  List<Object?> get props => [...super.props, type, errorData];
+}
+
+class UnknownFailureResponse extends FailureResponse {
+  UnknownFailureResponse([Object? error]) : super(message: error.toString());
+}

packages/clean_framework/lib/src/core/gateway/gateway.dart

@@ -0,0 +1,101 @@
+import 'dart:async';
+
+import 'package:clean_framework/src/core/external_interface/request.dart';
+import 'package:clean_framework/src/core/external_interface/response.dart';
+import 'package:clean_framework/src/core/use_case/use_case.dart';
+import 'package:clean_framework/src/core/use_case/use_case_provider.dart';
+import 'package:clean_framework/src/utilities/clean_framework_observer.dart';
+import 'package:clean_framework/src/utilities/either.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:meta/meta.dart';
+
+abstract class Gateway<O extends Output, R extends Request,
+    P extends SuccessResponse, S extends SuccessInput> {
+  UseCase? _useCase;
+
+  void attach(
+    ProviderRef<Object> ref, {
+    required List<UseCaseProvider> providers,
+  }) {
+    for (final useCaseProvider in providers) {
+      useCaseProvider.notifier.then(
+        (notifier) {
+          ref
+              .read(notifier)
+              .subscribe<O, S>((output) => buildInput(output as O));
+        },
+      );
+    }
+  }
+
+  @visibleForTesting
+  @nonVirtual
+  // ignore: use_setters_to_change_properties
+  void feedResponse(Responder<R, P> feeder) => _responder = feeder;
+
+  @visibleForTesting
+  @nonVirtual
+  Future<Either<FailureInput, S>> buildInput(O output) {
+    return _processRequest(buildRequest(output));
+  }
+
+  late final Responder<R, P> _responder;
+
+  S onSuccess(covariant P response);
+  FailureInput onFailure(covariant FailureResponse failureResponse);
+  R buildRequest(O output);
+
+  Future<Either<FailureInput, S>> _processRequest(R request) async {
+    final either = await _responder(request);
+    return either.fold(
+      (failureResponse) => Either.left(_onFailure(failureResponse)),
+      (response) => Either.right(onSuccess(response)),
+    );
+  }
+
+  FailureInput _onFailure(FailureResponse failureResponse) {
+    final failureInput = onFailure(failureResponse);
+    CleanFrameworkObserver.instance.onFailureInput(failureInput);
+    return failureInput;
+  }
+}
+
+abstract class BridgeGateway<SUBSCRIBER_OUTPUT extends Output,
+    PUBLISHER_OUTPUT extends Output, SUBSCRIBER_INPUT extends Input> {
+  BridgeGateway({
+    required UseCase subscriberUseCase,
+    required UseCase publisherUseCase,
+  })  : _subscriberUseCase = subscriberUseCase,
+        _publisherUseCase = publisherUseCase {
+    _subscriberUseCase.subscribe<SUBSCRIBER_OUTPUT, SUBSCRIBER_INPUT>(
+      (output) {
+        return Either<FailureInput, SUBSCRIBER_INPUT>.right(
+          onResponse(
+            _publisherUseCase.getOutput<PUBLISHER_OUTPUT>(),
+          ),
+        );
+      },
+    );
+  }
+  late final UseCase _subscriberUseCase;
+  late final UseCase _publisherUseCase;
+
+  SUBSCRIBER_INPUT onResponse(PUBLISHER_OUTPUT output);
+}
+
+abstract class WatcherGateway<
+    O extends Output,
+    R extends Request,
+    P extends SuccessResponse,
+    S extends SuccessInput> extends Gateway<O, R, P, S> {
+  @override
+  FailureInput onFailure(FailureResponse failureResponse) => FailureInput();
+
+  @nonVirtual
+  void yieldResponse(P response) {
+    _useCase?.setInput(onSuccess(response));
+  }
+}
+
+typedef Responder<R extends Request, P extends SuccessResponse>
+    = FutureOr<Either<FailureResponse, P>> Function(R request);

packages/clean_framework/lib/src/core/gateway/gateway_provider.dart

@@ -0,0 +1,20 @@
+import 'package:clean_framework/src/core/clean_framework_provider.dart';
+import 'package:clean_framework/src/core/gateway/gateway.dart';
+import 'package:clean_framework/src/core/use_case/use_case_provider.dart';
+import 'package:meta/meta.dart';
+import 'package:riverpod/riverpod.dart';
+
+class GatewayProvider<G extends Gateway>
+    extends CleanFrameworkProvider<Provider<G>> {
+  GatewayProvider(
+    G Function() create, {
+    List<UseCaseProvider> useCases = const [],
+  }) : super(
+          provider: Provider(
+            (ref) => create()..attach(ref, providers: useCases),
+          ),
+        );
+
+  @visibleForTesting
+  G read(ProviderContainer container) => container.read(call());
+}