refactor(rest_client): Rewrite rest client on steroids

core/rest_client/lib/rest_client.dart

@@ -1,4 +1,6 @@
-export 'src/exception/rest_client_exception.dart';
-export 'src/http/rest_client_http.dart';
-export 'src/rest_client.dart';
-export 'src/rest_client_base.dart';
+export 'src/core/rest_client.dart';
+export 'src/core/rest_client_base.dart';
+export 'src/core/rest_client_intercepted.dart';
+export 'src/core/rest_client_interceptor.dart';
+export 'src/model/rest_request.dart';
+export 'src/model/rest_response.dart';

core/rest_client/lib/src/core/rest_client.dart

@@ -0,0 +1,6 @@
+import 'package:rest_client/rest_client.dart';
+
+abstract interface class RestClient {
+  Future<RestResponse> send(RestRequest request);
+  Future<RestResponse> sendMultipart(RestRequestMultipart request);
+}

core/rest_client/lib/src/core/rest_client_base.dart

@@ -0,0 +1,27 @@
+import 'package:rest_client/rest_client.dart';
+
+abstract base class RestClientBase implements RestClient {
+  Future<RestResponse> get(String url, {Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), headers: headers, method: 'GET'));
+  }
+
+  Future<RestResponse> post(String url, {Object? body, Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), body: body, headers: headers, method: 'POST'));
+  }
+
+  Future<RestResponse> put(String url, {Object? body, Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), body: body, headers: headers, method: 'PUT'));
+  }
+
+  Future<RestResponse> delete(String url, {Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), headers: headers, method: 'DELETE'));
+  }
+
+  Future<RestResponse> patch(String url, {Object? body, Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), body: body, headers: headers, method: 'PATCH'));
+  }
+
+  Future<RestResponse> head(String url, {Map<String, String>? headers}) {
+    return send(RestRequestBasic(url: Uri.parse(url), headers: headers, method: 'HEAD'));
+  }
+}

core/rest_client/lib/src/core/rest_client_intercepted.dart

@@ -0,0 +1,25 @@
+import 'package:rest_client/rest_client.dart';
+
+abstract base class RestClientIntercepted extends RestClientBase {
+  @override
+  Future<RestResponse> send(RestRequest request) {
+    // TODO: implement send
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<RestResponse> sendMultipart(RestRequestMultipart request) {
+    // TODO: implement sendMultipart
+    throw UnimplementedError();
+  }
+
+  /// Sends a [RestRequest] and returns a [RestResponse].
+  ///
+  /// This method is used by [RestClientIntercepted] to handle requests.
+  Future<RestResponse> sendInternal(RestRequest request);
+
+  /// Sends a [RestRequestMultipart] and returns a [RestResponse].
+  ///
+  /// This method is used by [RestClientIntercepted] to handle multipart requests.
+  Future<RestResponse> sendMultipartInternal(RestRequestMultipart request);
+}

core/rest_client/lib/src/core/rest_client_interceptor.dart

@@ -0,0 +1,37 @@
+// ignore_for_file: avoid-unnecessary-reassignment
+
+import 'dart:async';
+
+import 'package:rest_client/rest_client.dart';
+
+abstract interface class RestClientInterceptor {
+  /// Intercepts a [RestRequest] before it is sent.
+  Future<RestRequest> interceptRequest(RestRequest request);
+
+  /// Intercepts a [RestResponse] after it is received.
+  Future<RestResponse> interceptResponse(RestResponse response);
+
+  /// Intercepts an error that occurs during the request.
+  Future<void> interceptError(Object error, StackTrace stackTrace);
+}
+
+mixin QueuedOperations {
+  final Map<String, Future<Object?>> _queues = {};
+
+  /// Runs an operation in a named queue, ensuring sequential execution
+  Future<T> runQueued<T>(String queueName, Future<T> Function() operation) {
+    final previousOperation = _queues[queueName] ?? Future.value();
+    var newOperation = previousOperation.then((_) => operation());
+
+    newOperation = newOperation.whenComplete(() {
+      if (_queues[queueName] == newOperation) {
+        _queues.remove(queueName);
+      }
+    });
+
+    // Update the queue with the new operation
+    _queues[queueName] = newOperation;
+
+    return newOperation;
+  }
+}