chore(wyatt_cd): add wyatt continuous deployment package

packages/wyatt_architecture/example/lib/data/repositories/photo_repository_impl.dart

@@ -88,8 +88,8 @@ class PhotoRepositoryImpl extends PhotoRepository {
       }
       return Ok(response);
     } catch (_) {
-      return const Err(
-        ClientException('Cannot retrieve all photos from favorites.'),
+      return Err(
+        const ClientException('Cannot retrieve all photos from favorites.'),
       );
     }
   }

packages/wyatt_architecture/example/lib/domain/data_sources/local/favorite_local_data_source.dart

@@ -17,7 +17,7 @@
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
-abstract class FavoriteLocalDataSource extends BaseLocalDataSource {
+abstract class FavoriteLocalDataSource extends BaseDataSource {
   Future<void> addPhotoToFavorites(Photo photo);
   Future<void> deletePhotoFromFavorites(int id);
   Future<List<int>> getAllPhotosFromFavorites();

packages/wyatt_architecture/example/lib/domain/data_sources/remote/album_remote_data_source.dart

@@ -17,7 +17,7 @@
 import 'package:architecture_example/domain/entities/album.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
-abstract class AlbumRemoteDataSource extends BaseRemoteDataSource {
+abstract class AlbumRemoteDataSource extends BaseDataSource {
   Future<Album> getAlbum(int id);
   Future<List<Album>> getAllAlbums({int? start, int? limit});
 }

packages/wyatt_architecture/example/lib/domain/data_sources/remote/photo_remote_data_source.dart

@@ -17,7 +17,7 @@
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
-abstract class PhotoRemoteDataSource extends BaseRemoteDataSource {
+abstract class PhotoRemoteDataSource extends BaseDataSource {
   Future<Photo> getPhoto(int id);
   Future<List<Photo>> getAllPhotos({int? start, int? limit});
   Future<List<Photo>> getPhotosFromAlbum(int albumId, {int? start, int? limit});

packages/wyatt_architecture/example/lib/domain/usecases/photos/add_photo_to_favorites.dart

@@ -14,26 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class AddPhotoToFavorites extends AsyncUseCase<Photo, List<Photo>> {
-  AddPhotoToFavorites(this._photoRepository);
+  const AddPhotoToFavorites(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<List<Photo>> execute(Photo? params) async {
-    await _photoRepository.addPhotoToFavorites(params!);
+  FutureOrResult<List<Photo>> execute(Photo params) async {
+    await _photoRepository.addPhotoToFavorites(params);
     return _photoRepository.getAllPhotosFromFavorites();
   }
-
-  @override
-  FutureOr<void> onStart(Photo? params) {
-    if (params == null) {
-      throw const ClientException('Photo cannot be null');
-    }
-  }
 }

packages/wyatt_architecture/example/lib/domain/usecases/photos/check_if_photo_is_in_favorites.dart

@@ -14,23 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class CheckIfPhotoIsInFavorites extends AsyncUseCase<int, bool> {
-  CheckIfPhotoIsInFavorites(this._photoRepository);
+  const CheckIfPhotoIsInFavorites(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<bool> execute(int? params) async =>
-      _photoRepository.checkIfPhotoIsInFavorites(params!);
-
-  @override
-  FutureOr<void> onStart(int? params) {
-    if (params == null) {
-      throw const ClientException('id cannot be null');
-    }
-  }
+  FutureOrResult<bool> execute(int params) async =>
+      _photoRepository.checkIfPhotoIsInFavorites(params);
 }

packages/wyatt_architecture/example/lib/domain/usecases/photos/display_favorites.dart

@@ -18,12 +18,12 @@ import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
-class DisplayFavorites extends AsyncUseCase<NoParam, List<Photo>> {
-  DisplayFavorites(this._photoRepository);
+class DisplayFavorites extends NoParamsAsyncUseCase<List<Photo>> {
+  const DisplayFavorites(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<List<Photo>> execute(void params) {
+  FutureOrResult<List<Photo>> execute() {
     final photos = _photoRepository.getAllPhotosFromFavorites();
     return photos;
   }

packages/wyatt_architecture/example/lib/domain/usecases/photos/display_photo.dart

@@ -14,26 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class DisplayPhoto extends AsyncUseCase<int, Photo> {
-  DisplayPhoto(this._photoRepository);
+  const DisplayPhoto(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<Photo> execute(int? params) {
-    final photo = _photoRepository.getPhoto(params!);
+  FutureOrResult<Photo> execute(int params) {
+    final photo = _photoRepository.getPhoto(params);
     return photo;
   }
-
-  @override
-  FutureOr<void> onStart(int? params) {
-    if (params == null) {
-      throw const ClientException('id cannot be null');
-    }
-  }
 }

packages/wyatt_architecture/example/lib/domain/usecases/photos/open_album.dart

@@ -14,32 +14,23 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:architecture_example/domain/usecases/photos/params/query_parameters.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class OpenAlbum extends AsyncUseCase<QueryParameters, List<Photo>> {
-  OpenAlbum(this._photoRepository);
+  const OpenAlbum(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<List<Photo>> execute(QueryParameters? params) {
+  FutureOrResult<List<Photo>> execute(QueryParameters params) {
     final photos = _photoRepository.getPhotosFromAlbum(
-      params!.albumId,
+      params.albumId,
       start: params.start,
       limit: params.limit,
     );
 
     return photos;
   }
-
-  @override
-  FutureOr<void> onStart(QueryParameters? params) {
-    if (params == null) {
-      throw const ClientException('params cannot be null');
-    }
-  }
 }

packages/wyatt_architecture/example/lib/domain/usecases/photos/remove_photo_from_favorites.dart

@@ -14,26 +14,17 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/entities/photo.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class RemovePhotoFromFavorites extends AsyncUseCase<int, List<Photo>> {
-  RemovePhotoFromFavorites(this._photoRepository);
+  const RemovePhotoFromFavorites(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<List<Photo>> execute(int? params) async {
-    await _photoRepository.deletePhotoFromFavorites(params!);
+  FutureOrResult<List<Photo>> execute(int params) async {
+    await _photoRepository.deletePhotoFromFavorites(params);
     return _photoRepository.getAllPhotosFromFavorites();
   }
-
-  @override
-  FutureOr<void> onStart(int? params) {
-    if (params == null) {
-      throw const ClientException('id cannot be null');
-    }
-  }
 }

packages/wyatt_architecture/example/lib/domain/usecases/photos/retrieve_all_albums.dart

@@ -14,30 +14,21 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'dart:async';
-
 import 'package:architecture_example/domain/entities/album.dart';
 import 'package:architecture_example/domain/repositories/photo_repository.dart';
 import 'package:architecture_example/domain/usecases/photos/params/query_parameters.dart';
 import 'package:wyatt_architecture/wyatt_architecture.dart';
 
 class RetrieveAllAlbums extends AsyncUseCase<QueryParameters, List<Album>> {
-  RetrieveAllAlbums(this._photoRepository);
+  const RetrieveAllAlbums(this._photoRepository);
   final PhotoRepository _photoRepository;
 
   @override
-  FutureOrResult<List<Album>> execute(QueryParameters? params) {
+  FutureOrResult<List<Album>> execute(QueryParameters params) {
     final albums = _photoRepository.getAllAlbums(
-      start: params!.start,
+      start: params.start,
       limit: params.limit,
     );
     return albums;
   }
-
-  @override
-  FutureOr<void> onStart(QueryParameters? params) {
-    if (params == null) {
-      throw const ClientException('params cannot be null');
-    }
-  }
 }

packages/wyatt_architecture/lib/src/core/core.dart

@@ -15,3 +15,5 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 export 'exceptions/exceptions.dart';
+export 'extensions/object_extension.dart';
+export 'mixins/observers.dart';

packages/wyatt_architecture/lib/src/core/exceptions/exceptions.dart

@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'package:wyatt_type_utils/wyatt_type_utils.dart';
-
 /// {@template app_exception}
 /// [AppException] is a base class for all exceptions in the wyatt architecture.
 /// {@endtemplate}
@@ -27,7 +25,7 @@ abstract class AppException implements Exception {
 
   @override
   String toString() {
-    if (message.isNotNullOrEmpty) {
+    if (message?.isNotEmpty ?? false) {
       return '$runtimeType: $message';
     } else {
       return '$runtimeType: An exception occured';

packages/wyatt_architecture/lib/src/core/extensions/object_extension.dart

@@ -0,0 +1,23 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:wyatt_architecture/src/core/exceptions/exceptions.dart';
+
+extension ObjectExtension on Object? {
+  AppException toException() => this is AppException
+      ? this! as AppException
+      : ClientException(this?.toString());
+}

packages/wyatt_architecture/lib/src/core/mixins/observers.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -16,30 +16,26 @@
 
 import 'dart:async';
 
-import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_architecture/src/core/exceptions/exceptions.dart';
+import 'package:wyatt_architecture/src/domain/usecase.dart';
 
 /// Usecase observers
-mixin Observer<Parameters, ReturnType> {
+mixin Observer<I, O> {
   /// Called before usecase is runned.
   /// Useful to check the preconditions
-  FutureOr<void> onStart(Parameters? params) {}
-
-  /// Called when error occures during main scenario
-  /// Useful to run alternative scenario
-  FutureOr<void> onError(AppException? error) {}
+  FutureOr<void> onStart(I? params) {}
 }
 
-/// Specific observer for classic usecase
-mixin AsyncObserver<ReturnType> {
-  /// Called when usecase is completed
-  FutureOr<void> onComplete(ReturnType? data) {}
+/// Exception observer
+mixin ExceptionObserver<O> {
+  /// Called on error
+  /// Useful to handle exceptions
+  FutureOr<void> onError(AppException e) {}
 }
 
-/// Specific observer for stream case usecase
-mixin StreamObserver<ReturnType> {
-  /// Replaces the data event handler of this subscription.
-  void onDone() {}
-
-  /// Replaces the done event handler of this subscription.
-  void onData(ReturnType? data) {}
+/// Completer observer
+mixin CompleterObserver<O> {
+  /// Called after usecase is runned.
+  /// Useful to log the result
+  FutureOr<void> onComplete(Res<O>? result) {}
 }

packages/wyatt_architecture/lib/src/data/base_data_source.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify

packages/wyatt_architecture/lib/src/domain/domain.dart

@@ -1,20 +1,19 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
-//
+// 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // any later version.
-//
+// 
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU General Public License for more details.
-//
+// 
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'data_sources/data_sources.dart';
-export 'entities/entities.dart';
-export 'repositories/repositories.dart';
-export 'usecases/usecases.dart';
+export 'base_repository.dart';
+export 'entity.dart';
+export 'usecase.dart';

packages/wyatt_architecture/lib/src/domain/usecase.dart

@@ -0,0 +1,153 @@
+// Copyright (C) 2022 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+
+import 'package:generic_usecase/generic_usecase.dart' as generic;
+import 'package:wyatt_architecture/src/core/exceptions/exceptions.dart';
+import 'package:wyatt_architecture/src/core/extensions/object_extension.dart';
+import 'package:wyatt_architecture/src/core/mixins/observers.dart';
+import 'package:wyatt_type_utils/wyatt_type_utils.dart';
+
+typedef Res<T> = Result<T, AppException>;
+typedef FutureOrResult<T> = FutureOr<Res<T>>;
+typedef StreamResult<T> = Stream<Res<T>>;
+
+/// A wrapper around [Result] to make it easier to use with AppException.
+Future<Res<T>> unsafe<T>(FutureOr<T> Function() fn) =>
+    Result.tryCatchAsync<T, AppException, Object>(
+      () => Future.sync(fn),
+      (e) => e.toException(),
+    );
+
+abstract class AsyncUseCase<I, O> extends generic.Usecase<I, Res<O>>
+    with Observer<I, O>, ExceptionObserver<O>, CompleterObserver<O> {
+  const AsyncUseCase() : super();
+
+  @override
+  FutureOr<generic.ConditionsResult> checkPreconditions(I? params) async {
+    try {
+      await onStart(params);
+      return generic.ConditionsResult(isValid: true);
+    } catch (e) {
+      return generic.ConditionsResult(isValid: false, message: e.toString());
+    }
+  }
+
+  @override
+  FutureOr<generic.ConditionsResult> checkPostconditions(Res<O>? result) async {
+    try {
+      await onComplete(result);
+      return generic.ConditionsResult(isValid: true);
+    } catch (e) {
+      return generic.ConditionsResult(isValid: false, message: e.toString());
+    }
+  }
+
+  @override
+  FutureOrResult<O> onException(Object e) async {
+    final exception = e.toException();
+    await onError(exception);
+
+    return Err(exception);
+  }
+}
+
+abstract class NoParamsAsyncUseCase<O> extends generic.NoParamsUsecase<Res<O>>
+    with ExceptionObserver<O>, CompleterObserver<O> {
+  const NoParamsAsyncUseCase() : super();
+
+  @override
+  FutureOr<generic.ConditionsResult> checkPostconditions(Res<O>? result) async {
+    try {
+      await onComplete(result);
+      return generic.ConditionsResult(isValid: true);
+    } catch (e) {
+      return generic.ConditionsResult(isValid: false, message: e.toString());
+    }
+  }
+
+  @override
+  FutureOrResult<O> onException(Object e) async {
+    final exception = e.toException();
+    await onError(exception);
+
+    return Err(exception);
+  }
+}
+
+abstract class StreamUseCase<I, O> extends generic.StreamUsecase<I, Res<O>>
+    with Observer<I, O>, ExceptionObserver<O> {
+  const StreamUseCase() : super();
+
+  @override
+  FutureOr<generic.ConditionsResult> checkPreconditions(I? params) async {
+    try {
+      await onStart(params);
+      return generic.ConditionsResult(isValid: true);
+    } catch (e) {
+      return generic.ConditionsResult(isValid: false, message: e.toString());
+    }
+  }
+
+  StreamSubscription<Res<O>> listen(
+    I params,
+    void Function(Res<O>)? onData, {
+    Function? onError,
+    void Function()? onDone,
+    bool? cancelOnError,
+  }) =>
+      super.call(params).listen(
+            onData,
+            onError: onError,
+            onDone: onDone,
+            cancelOnError: cancelOnError,
+          );
+
+  @override
+  FutureOrResult<O> onException(Object e) async {
+    final exception = e.toException();
+    await onError(exception);
+
+    return Err(exception);
+  }
+}
+
+abstract class NoParamsStreamUseCase<O>
+    extends generic.NoParamsStreamUsecase<Res<O>> with ExceptionObserver<O> {
+  const NoParamsStreamUseCase() : super();
+
+  StreamSubscription<Res<O>> listen(
+    void Function(Res<O>)? onData, {
+    Function? onError,
+    void Function()? onDone,
+    bool? cancelOnError,
+  }) =>
+      super.call().listen(
+            onData,
+            onError: onError,
+            onDone: onDone,
+            cancelOnError: cancelOnError,
+          );
+
+  @override
+  FutureOrResult<O> onException(Object e) async {
+    final exception = e.toException();
+    await onError(exception);
+
+    return Err(exception);
+  }
+}

packages/wyatt_architecture/lib/src/domain/usecases/usecase.dart

@@ -1,100 +0,0 @@
-// Copyright (C) 2022 WYATT GROUP
-// Please see the AUTHORS file for details.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-import 'dart:async';
-
-import 'package:wyatt_architecture/src/core/exceptions/exceptions.dart';
-import 'package:wyatt_architecture/src/domain/usecases/observers.dart';
-import 'package:wyatt_type_utils/wyatt_type_utils.dart';
-
-typedef FutureOrResult<T> = FutureOr<Result<T, AppException>>;
-typedef StreamResult<T> = Stream<Result<T, AppException>>;
-
-/// {@template base_usecase}
-/// Abstract class of any use case.
-/// {@endtemplate}
-abstract class BaseUseCase<Parameters, ReturnType> {
-  /// {@macro base_usecase}
-  const BaseUseCase();
-
-  /// Run use case scenarios
-  ReturnType call(Parameters parameters);
-
-  /// Private function to implement main scenario
-  /// of your usecase.
-  ReturnType execute(Parameters params);
-}
-
-/// {@template usecase}
-/// Abstract class of a use case that deals specifically
-/// with the response and its state.
-/// {@endtemplate}
-abstract class UseCase<Parameters, ReturnType>
-    extends BaseUseCase<Parameters?, FutureOrResult<ReturnType>>
-    with Observer<Parameters, ReturnType> {
-  /// {@macro usecase}
-  const UseCase();
-
-  FutureOr<void> _onSuccess(ReturnType data);
-
-  /// Supports the result of the main scenario and integrates
-  /// some alternative scenarios if necessary.
-  @override
-  FutureOrResult<ReturnType> call(Parameters? parameters) async {
-    try {
-      await onStart(parameters);
-      final response = await execute(parameters);
-      if (response.isErr) {
-        await onError(response.err);
-      } else if (response.isOk && response.ok != null) {
-        await _onSuccess(response.ok as ReturnType);
-      }
-      return response;
-    } catch (e) {
-      return Err(ClientException(e.toString()));
-    }
-  }
-}
-
-/// {@template async_usecase}
-/// Abtstract classic usecase bases on futures
-/// {@endtemplate}
-abstract class AsyncUseCase<Parameters, ReturnType>
-    extends UseCase<Parameters?, ReturnType> with AsyncObserver<ReturnType> {
-  /// {@macro async_usecase}
-  const AsyncUseCase();
-
-  @override
-  FutureOr<void> _onSuccess(ReturnType data) => onComplete(data);
-}
-
-/// {@template stream_usecase}
-/// Abstract specific usecase bases on streams
-/// {@endtemplate}
-abstract class StreamUseCase<Parameters, ReturnType>
-    extends UseCase<Parameters?, Stream<ReturnType>>
-    with StreamObserver<ReturnType> {
-  /// {@macro stream_usecase}
-  const StreamUseCase();
-
-  @override
-  FutureOr<void> _onSuccess(Stream<ReturnType> data) {
-    data.listen(
-      onData,
-      onDone: onDone,
-    );
-  }
-}

packages/wyatt_architecture/lib/src/domain/usecases/usecases.dart

@@ -1,19 +0,0 @@
-// Copyright (C) 2022 WYATT GROUP
-// Please see the AUTHORS file for details.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-export 'no_param.dart';
-export 'observers.dart';
-export 'usecase.dart';

packages/wyatt_architecture/lib/src/src.dart

@@ -15,4 +15,5 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 export 'core/core.dart';
+export 'data/base_data_source.dart';
 export 'domain/domain.dart';

packages/wyatt_architecture/pubspec.yaml

@@ -1,16 +1,16 @@
 # Copyright (C) 2023 WYATT GROUP
 # Please see the AUTHORS file for details.
-# 
+#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # any later version.
-# 
+#
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
@@ -22,9 +22,10 @@ version: 0.2.0+1
 publish_to: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
 
 environment:
-  sdk: ">=2.17.0 <3.0.0"
+  sdk: "^3.0.0"
 
 dependencies:
+  generic_usecase: ^3.0.0
   wyatt_type_utils:
     hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
     version: ^0.0.5
@@ -32,4 +33,4 @@ dependencies:
 dev_dependencies:
   wyatt_analysis:
     hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
-    version: ^2.5.0
+    version: ^2.6.1

packages/wyatt_continuous_deployment/.gitignore

@@ -0,0 +1,7 @@
+# https://dart.dev/guides/libraries/private-files
+# Created by `dart pub`
+.dart_tool/
+
+# Avoid committing pubspec.lock for library packages; see
+# https://dart.dev/guides/libraries/private-files#pubspeclock.
+pubspec.lock

packages/wyatt_continuous_deployment/.vscode/launch.json

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 WYATT GROUP
+ * Please see the AUTHORS file for details.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Example",
+            "request": "launch",
+            "type": "dart",
+            "cwd": "example/",
+            "program": "lib/main.dart",
+            "flutterMode": "debug"
+        },
+    ]
+}

packages/wyatt_continuous_deployment/.vscode/settings.json

@@ -0,0 +1,72 @@
+{
+  "dart.runPubGetOnPubspecChanges": "never",
+  "bloc.newCubitTemplate.type": "equatable",
+  "psi-header.changes-tracking": {
+    "isActive": true
+  },
+  "psi-header.config": {
+    "blankLinesAfter": 1,
+    "forceToTop": true
+  },
+  "psi-header.lang-config": [
+    {
+      "beforeHeader": [
+        "# -*- coding:utf-8 -*-",
+        "#!/usr/bin/env python3"
+      ],
+      "begin": "###",
+      "end": "###",
+      "language": "python",
+      "prefix": "# "
+    },
+    {
+      "beforeHeader": [
+        "#!/usr/bin/env sh",
+        ""
+      ],
+      "language": "shellscript",
+      "begin": "",
+      "end": "",
+      "prefix": "# "
+    },
+    {
+      "begin": "",
+      "end": "",
+      "language": "dart",
+      "prefix": "// "
+    },
+    {
+      "begin": "",
+      "end": "",
+      "language": "yaml",
+      "prefix": "# "
+    },
+    {
+      "begin": "<!--",
+      "end": "-->",
+      "language": "markdown",
+    },
+  ],
+  "psi-header.templates": [
+    {
+      "language": "*",
+      "template": [
+        "Copyright (C) <<year>> WYATT GROUP",
+        "Please see the AUTHORS file for details.",
+        "",
+        "This program is free software: you can redistribute it and/or modify",
+        "it under the terms of the GNU General Public License as published by",
+        "the Free Software Foundation, either version 3 of the License, or",
+        "any later version.",
+        "",
+        "This program is distributed in the hope that it will be useful,",
+        "but WITHOUT ANY WARRANTY; without even the implied warranty of",
+        "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
+        "GNU General Public License for more details.",
+        "",
+        "You should have received a copy of the GNU General Public License",
+        "along with this program. If not, see <https://www.gnu.org/licenses/>."
+      ],
+    }
+  ],
+}

packages/wyatt_continuous_deployment/AUTHORS

@@ -0,0 +1,8 @@
+# Below is a list of people and organizations that have contributed
+# to this project. Names should be added to the list like so:
+#
+#   Name/Organization <email address>
+
+Wyatt Group S.A.S
+Hugo Pointcheval <hugo.pointcheval@wyatt-studio.fr>
+Malo Léon <malo.leon@wyatt-studio.fr>

packages/wyatt_continuous_deployment/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0
+
+- Initial version.

packages/wyatt_continuous_deployment/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

packages/wyatt_continuous_deployment/README.md

@@ -0,0 +1,56 @@
+<!--
+ * Copyright (C) 2023 WYATT GROUP
+ * Please see the AUTHORS file for details.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+-->
+
+
+
+
+
+# Dart - Wyatt Continuous Deployment
+
+<p align="left">
+  <a href="https://git.wyatt-studio.fr/Wyatt-FOSS/wyatt-packages/src/branch/master/packages/wyatt_analysis"><img src="https://img.shields.io/badge/Style-Wyatt%20Analysis-blue.svg?style=flat-square" alt="Style: Wyatt Analysis" /></a>
+  <img src="https://img.shields.io/badge/SDK-Dart%20%7C%20Flutter-blue?style=flat-square" alt="SDK: Dart & Flutter" />
+</p>
+
+
+
+Wyatt c d
+
+## Features
+
+TODO: List what your package can do. Maybe include images, gifs, or videos.
+
+## Getting started
+
+TODO: List prerequisites and provide or point to information on how to
+start using the package.
+
+## Usage
+
+TODO: Include short and useful examples for package users. Add longer examples
+to `/example` folder. 
+
+```dart
+const like = 'sample';
+```
+
+## Additional information
+
+TODO: Tell users more about the package: where to find more information, how to 
+contribute to the package, how to file issues, what response they can expect 
+from the package authors, and more.

packages/wyatt_continuous_deployment/analysis_options.yaml

@@ -0,0 +1,27 @@
+include: package:wyatt_analysis/analysis_options.yaml
+
+analyzer:
+  plugins:
+    - dart_code_linter
+
+dart_code_linter:
+  anti-patterns:
+    - long-method
+    - long-parameter-list
+  metrics:
+    cyclomatic-complexity: 20
+    maximum-nesting-level: 5
+    number-of-parameters: 10
+    source-lines-of-code: 400
+  metrics-exclude:
+    - test/**
+  rules:
+    - newline-before-return
+    - no-boolean-literal-compare
+    - no-empty-block
+    - prefer-trailing-comma
+    - prefer-conditional-expressions
+    - no-equal-then-else
+    - avoid-border-all
+    - prefer-const-border-radius
+    - prefer-using-list-view

packages/wyatt_continuous_deployment/example/.gitignore

@@ -0,0 +1,44 @@
+# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.buildlog/
+.history
+.svn/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
+# Flutter/Dart/Pub related
+**/doc/api/
+**/ios/Flutter/.last_build_id
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+.packages
+.pub-cache/
+.pub/
+/build/
+
+# Symbolication related
+app.*.symbols
+
+# Obfuscation related
+app.*.map.json
+
+# Android Studio will place build artifacts here
+/android/app/debug
+/android/app/profile
+/android/app/release

packages/wyatt_continuous_deployment/example/.metadata

@@ -0,0 +1,30 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled.
+
+version:
+  revision: b06b8b2710955028a6b562f5aa6fe62941d6febf
+  channel: stable
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: b06b8b2710955028a6b562f5aa6fe62941d6febf
+      base_revision: b06b8b2710955028a6b562f5aa6fe62941d6febf
+    - platform: web
+      create_revision: b06b8b2710955028a6b562f5aa6fe62941d6febf
+      base_revision: b06b8b2710955028a6b562f5aa6fe62941d6febf
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

packages/wyatt_continuous_deployment/example/README.md

@@ -0,0 +1,16 @@
+# example
+
+A new Flutter project.
+
+## Getting Started
+
+This project is a starting point for a Flutter application.
+
+A few resources to get you started if this is your first Flutter project:
+
+- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
+- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook)
+
+For help getting started with Flutter development, view the
+[online documentation](https://docs.flutter.dev/), which offers tutorials,
+samples, guidance on mobile development, and a full API reference.

packages/wyatt_continuous_deployment/example/analysis_options.yaml

@@ -0,0 +1,7 @@
+
+
+
+include: package:wyatt_analysis/analysis_options.yaml
+
+
+

packages/wyatt_continuous_deployment/example/lib/main.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,13 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'package:wyatt_architecture/src/domain/entities/entity.dart';
+import 'package:wyatt_continuous_deployment/wyatt_continuous_deployment.dart';
 
-/// {@template no_param}
-/// [NoParam] is a class that is used when a use case does not require any
-/// parameters.
-/// {@endtemplate}
-class NoParam extends Entity {
-  /// {@macro no_param}
-  const NoParam();
+class WyattContinuousDeploymentExample {
+  static Future<void> run(List<String> args) async {
+    const useCase = CheckToolsUsecase();
+
+    final result = await useCase();
+
+    result.fold((value) => print('Success'), (error) => print('Error: $error'));
+  }
 }

packages/wyatt_continuous_deployment/example/pubspec.yaml

@@ -0,0 +1,31 @@
+name: wyatt_continuous_deployment_example
+description: A new Flutter project.
+version: 1.0.0
+
+publish_to: 'none'
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+
+dependencies:
+
+
+  
+  wyatt_continuous_deployment:
+    path: "../"
+
+dev_dependencies:
+
+
+
+  test: ^1.21.0
+
+
+
+
+  wyatt_analysis:
+    hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
+    version: ^2.6.1
+
+
+

packages/wyatt_continuous_deployment/example/test/widget_test.dart

@@ -0,0 +1 @@
+

packages/wyatt_continuous_deployment/lib/src/core/constants/app_constants.dart

@@ -0,0 +1,30 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+abstract class AppConstants {
+  static const configFileName = 'wyatt.yaml';
+  static const requiredTools = ['fastlane', 'flutter', 'unzip', 'gpg'];
+
+  static const androidFolder = 'android';
+  static const androidBundleBuildPath =
+      'build/app/outputs/bundle/release/app-release.aab';
+  static const androidKeysSecretPassphrase = 'ANDROID_KEYS_SECRET_PASSPHRASE';
+  static const androidConfigKey = 'android';
+
+  static const iosFolder = 'ios';
+  static const iosKeysSecretPassphrase = 'IOS_KEYS_SECRET_PASSPHRASE';
+  static const iosConfigKey = 'ios';
+}

packages/wyatt_continuous_deployment/lib/src/core/injection/injectable.config.dart

@@ -0,0 +1,96 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+// **************************************************************************
+// InjectableConfigGenerator
+// **************************************************************************
+
+// ignore_for_file: type=lint
+// coverage:ignore-file
+
+// ignore_for_file: no_leading_underscores_for_library_prefixes
+import 'package:get_it/get_it.dart' as _i1;
+import 'package:injectable/injectable.dart' as _i2;
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart'
+    as _i21;
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane.dart'
+    as _i6;
+import 'package:wyatt_continuous_deployment/src/domain/entities/flutter.dart'
+    as _i12;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/config/get_android_config_usecase.dart'
+    as _i18;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/config/get_ios_config_usecase.dart'
+    as _i19;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/config/init_config_usecase.dart'
+    as _i20;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/decrypt_keys/decrypt_keys_usecase.dart'
+    as _i5;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_create_keychain_usecase.dart'
+    as _i7;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_deploy_pilot_usecase.dart'
+    as _i8;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_deploy_supply_usecase.dart'
+    as _i9;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_get_certificates_usecase.dart'
+    as _i10;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/find_last_ipa_file_usecase.dart'
+    as _i11;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_app_bundle_usecase.dart'
+    as _i13;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_ipa_usecase.dart'
+    as _i14;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_xcarchive_usecase.dart'
+    as _i15;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_clean_usecase.dart'
+    as _i16;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_pub_get_usecase.dart'
+    as _i17;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/requirements/check_config_file_usecase.dart'
+    as _i3;
+import 'package:wyatt_continuous_deployment/src/domain/usecases/requirements/check_tools_usecase.dart'
+    as _i4;
+
+extension GetItInjectableX on _i1.GetIt {
+// initializes the registration of main-scope dependencies inside of GetIt
+  _i1.GetIt init({
+    String? environment,
+    _i2.EnvironmentFilter? environmentFilter,
+  }) {
+    final gh = _i2.GetItHelper(
+      this,
+      environment,
+      environmentFilter,
+    );
+    final registerModule = _$RegisterModule();
+    gh.singleton<_i3.CheckConfigFileUsecase>(
+        const _i3.CheckConfigFileUsecase());
+    gh.singleton<_i4.CheckToolsUsecase>(const _i4.CheckToolsUsecase());
+    gh.singleton<_i5.DecryptKeysUsecase>(const _i5.DecryptKeysUsecase());
+    gh.lazySingleton<_i6.Fastlane>(() => registerModule.fastlane);
+    gh.singleton<_i7.FastlaneCreateKeychainUsecase>(
+        _i7.FastlaneCreateKeychainUsecase());
+    gh.singleton<_i8.FastlaneDeployPilotUsecase>(
+        _i8.FastlaneDeployPilotUsecase());
+    gh.singleton<_i9.FastlaneDeploySupplyUsecase>(
+        _i9.FastlaneDeploySupplyUsecase());
+    gh.singleton<_i10.FastlaneGetCertificateUsecase>(
+        _i10.FastlaneGetCertificateUsecase());
+    gh.singleton<_i11.FindLastIpaFileUsecase>(
+        const _i11.FindLastIpaFileUsecase());
+    gh.lazySingleton<_i12.Flutter>(() => registerModule.flutter);
+    gh.singleton<_i13.FlutterBuildAppBundleUsecase>(
+        const _i13.FlutterBuildAppBundleUsecase());
+    gh.singleton<_i14.FlutterBuildIpaUsecase>(
+        const _i14.FlutterBuildIpaUsecase());
+    gh.singleton<_i15.FlutterBuildXcarchiveUsecase>(
+        const _i15.FlutterBuildXcarchiveUsecase());
+    gh.singleton<_i16.FlutterCleanUsecase>(const _i16.FlutterCleanUsecase());
+    gh.singleton<_i17.FlutterPubGetUsecase>(const _i17.FlutterPubGetUsecase());
+    gh.singleton<_i18.GetAndroidConfigUsecase>(
+        const _i18.GetAndroidConfigUsecase());
+    gh.singleton<_i19.GetIosConfigUsecase>(const _i19.GetIosConfigUsecase());
+    gh.singleton<_i20.InitConfigUsecase>(const _i20.InitConfigUsecase());
+    return this;
+  }
+}
+
+class _$RegisterModule extends _i21.RegisterModule {}

packages/wyatt_continuous_deployment/lib/src/core/injection/injectable.dart

@@ -0,0 +1,73 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:get_it/get_it.dart';
+import 'package:injectable/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.config.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/flutter.dart';
+
+final getIt = GetIt.instance;
+
+@InjectableInit(
+  initializerName: 'init',
+  preferRelativeImports: false,
+  asExtension: true,
+)
+abstract final class Injectable {
+  static Future<void> configureDependencies() => getIt.init().allReady();
+}
+
+@module
+abstract class RegisterModule {
+  @lazySingleton
+  Flutter get flutter => Flutter();
+
+  @lazySingleton
+  Fastlane get fastlane => Fastlane();
+}
+
+class UsecaseInjectable extends Singleton {
+  const UsecaseInjectable({
+    super.as,
+    super.env,
+    super.dispose,
+    super.scope,
+    super.order,
+  });
+}
+
+const usecase = UsecaseInjectable();
+
+class RepositoryInjectable extends Singleton {
+  const RepositoryInjectable({
+    super.as,
+    super.env,
+    super.dispose,
+    super.scope,
+    super.order,
+  });
+}
+
+class DataSourceInjectable extends Singleton {
+  const DataSourceInjectable({
+    super.as,
+    super.env,
+    super.dispose,
+    super.scope,
+    super.order,
+  });
+}

packages/wyatt_continuous_deployment/lib/src/core/utils/logging.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,4 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'entity.dart';
+import 'package:wyatt_continuous_deployment/wyatt_continuous_deployment.dart';
+
+final logger = WyattContinuousDeployment.logger;

packages/wyatt_continuous_deployment/lib/src/domain/domain.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,4 +14,5 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'base_repository.dart';
+export 'entities/entities.dart';
+export 'usecases/usecases.dart';

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/android_config.dart

@@ -0,0 +1,65 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:json_annotation/json_annotation.dart';
+
+part 'android_config.g.dart';
+
+@JsonSerializable(
+  anyMap: true,
+  fieldRename: FieldRename.snake,
+  checked: true,
+)
+class AndroidConfig {
+  const AndroidConfig({
+    required this.flutterArgs,
+    required this.encryptedKeyFileName,
+    required this.googleServiceAccountFileName,
+    required this.releaseStatus,
+    required this.androidFolderPath,
+    required this.track,
+    this.packageName,
+  });
+
+  factory AndroidConfig.fromJson(Map<dynamic, dynamic> json) =>
+      _$AndroidConfigFromJson(json);
+
+  Map<String, dynamic> toJson() => _$AndroidConfigToJson(this);
+
+  static const defaultValues = AndroidConfig(
+    flutterArgs: '',
+    encryptedKeyFileName: 'android_keys.zip.gpg',
+    googleServiceAccountFileName: 'service_account_key.json',
+    releaseStatus: 'draft',
+    track: 'internal',
+    androidFolderPath: 'android',
+  );
+
+  final String? packageName;
+  final String flutterArgs;
+  final String encryptedKeyFileName;
+  final String googleServiceAccountFileName;
+  final String androidFolderPath;
+  final String releaseStatus;
+  final String track;
+
+  File get encryptedKeyFile => File('$androidFolderPath/$encryptedKeyFileName');
+  File get googleServiceAccountFile =>
+      File('$androidFolderPath/$googleServiceAccountFileName');
+  Directory get androidDirectory => Directory(androidFolderPath);
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/android_config.g.dart

@@ -0,0 +1,46 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'android_config.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+AndroidConfig _$AndroidConfigFromJson(Map json) => $checkedCreate(
+      'AndroidConfig',
+      json,
+      ($checkedConvert) {
+        final val = AndroidConfig(
+          flutterArgs: $checkedConvert('flutter_args', (v) => v as String),
+          encryptedKeyFileName:
+              $checkedConvert('encrypted_key_file_name', (v) => v as String),
+          googleServiceAccountFileName: $checkedConvert(
+              'google_service_account_file_name', (v) => v as String),
+          releaseStatus: $checkedConvert('release_status', (v) => v as String),
+          androidFolderPath:
+              $checkedConvert('android_folder_path', (v) => v as String),
+          track: $checkedConvert('track', (v) => v as String),
+          packageName: $checkedConvert('package_name', (v) => v as String?),
+        );
+        return val;
+      },
+      fieldKeyMap: const {
+        'flutterArgs': 'flutter_args',
+        'encryptedKeyFileName': 'encrypted_key_file_name',
+        'googleServiceAccountFileName': 'google_service_account_file_name',
+        'releaseStatus': 'release_status',
+        'androidFolderPath': 'android_folder_path',
+        'packageName': 'package_name'
+      },
+    );
+
+Map<String, dynamic> _$AndroidConfigToJson(AndroidConfig instance) =>
+    <String, dynamic>{
+      'package_name': instance.packageName,
+      'flutter_args': instance.flutterArgs,
+      'encrypted_key_file_name': instance.encryptedKeyFileName,
+      'google_service_account_file_name': instance.googleServiceAccountFileName,
+      'android_folder_path': instance.androidFolderPath,
+      'release_status': instance.releaseStatus,
+      'track': instance.track,
+    };

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/appstore_connect_config.dart

@@ -0,0 +1,65 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/ios_config.dart';
+
+class AppStoreConnectConfig {
+  AppStoreConnectConfig({
+    required this.keyId,
+    required this.issuerId,
+    required this.keyFilePath,
+    required this.isKeyContentBase64,
+    required this.duration,
+    required this.inHouse,
+  });
+
+  factory AppStoreConnectConfig.fromJson(Map<String, dynamic> json) =>
+      AppStoreConnectConfig(
+        keyId: json['apple_key_id']?.toString(),
+        issuerId: json['apple_issuer_id']?.toString(),
+        keyFilePath: json['apple_key_content']?.toString(),
+        isKeyContentBase64: false,
+        duration: 500,
+        inHouse: false,
+      );
+
+  factory AppStoreConnectConfig.fromConfig(IosConfig config) =>
+      AppStoreConnectConfig(
+        keyId: config.appleKeyId,
+        issuerId: config.appleIssuerId,
+        keyFilePath:
+            '${config.iosFolderPath}/${config.appleApiPrivateKeyFileName}',
+        isKeyContentBase64: false,
+        duration: 500,
+        inHouse: false,
+      );
+
+  final String? keyId;
+  final String? issuerId;
+  final String? keyFilePath;
+  final bool? isKeyContentBase64;
+  final int? duration;
+  final bool? inHouse;
+
+  Map<String, dynamic> toJson(String key) => {
+        'key_id': keyId,
+        'issuer_id': issuerId,
+        'key': key,
+        'is_key_content_base64': isKeyContentBase64,
+        'duration': duration,
+        'in_house': inHouse,
+      };
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/init_config_parameters.dart

@@ -0,0 +1,28 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+class InitConfigParameters {
+  const InitConfigParameters({
+    required this.path,
+    required this.force,
+  });
+
+  final String path;
+  final bool force;
+
+  @override
+  String toString() => 'InitConfigParameters(path: $path, force: $force)';
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/ios_config.dart

@@ -0,0 +1,94 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:json_annotation/json_annotation.dart';
+
+part 'ios_config.g.dart';
+
+@JsonSerializable(
+  anyMap: true,
+  fieldRename: FieldRename.snake,
+  checked: true,
+)
+class IosConfig {
+  const IosConfig({
+    required this.appleApiPrivateKeyFileName,
+    required this.gitCertsPrivateKeyFileName,
+    required this.iosFolderPath,
+    required this.encryptedKeyFileName,
+    required this.developerAppIdentifier,
+    required this.teamName,
+    required this.appleIssuerId,
+    required this.gitUrl,
+    required this.gitPassphrase,
+    required this.developerAppId,
+    required this.userName,
+    required this.appleKeyId,
+    required this.teamId,
+    required this.provisionningProfiles,
+    required this.flutterArgs,
+    required this.iosKeysFileName,
+  });
+
+  factory IosConfig.fromJson(Map<dynamic, dynamic> json) =>
+      _$IosConfigFromJson(json);
+
+  Map<String, dynamic> toJson() => _$IosConfigToJson(this);
+
+  static const defaultValues = IosConfig(
+    iosFolderPath: 'ios',
+    encryptedKeyFileName: 'ios_keys.zip.gpg',
+    iosKeysFileName: 'ios_keys.json',
+    appleApiPrivateKeyFileName: 'key.p8',
+    gitCertsPrivateKeyFileName: '',
+    developerAppIdentifier: 'git-key',
+    teamName: '',
+    appleIssuerId: '',
+    gitUrl: '',
+    gitPassphrase: 'match-password',
+    developerAppId: '',
+    userName: '',
+    appleKeyId: '',
+    teamId: '',
+    provisionningProfiles: {},
+    flutterArgs: '',
+  );
+
+  final String flutterArgs;
+  final String iosFolderPath;
+  final String encryptedKeyFileName;
+  final String appleApiPrivateKeyFileName;
+  final String gitCertsPrivateKeyFileName;
+
+  final String iosKeysFileName;
+  final String developerAppId;
+  final String developerAppIdentifier;
+  final String teamId;
+  final String teamName;
+  final String userName;
+
+  final String appleIssuerId;
+  final String appleKeyId;
+
+  final String gitPassphrase;
+  final String gitUrl;
+  final Map<String, String> provisionningProfiles;
+
+  File get encryptedKeyFile => File('$iosFolderPath/$encryptedKeyFileName');
+  Directory get iosDirectory => Directory(iosFolderPath);
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/config/ios_config.g.dart

@@ -0,0 +1,77 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'ios_config.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+IosConfig _$IosConfigFromJson(Map json) => $checkedCreate(
+      'IosConfig',
+      json,
+      ($checkedConvert) {
+        final val = IosConfig(
+          appleApiPrivateKeyFileName: $checkedConvert(
+              'apple_api_private_key_file_name', (v) => v as String),
+          gitCertsPrivateKeyFileName: $checkedConvert(
+              'git_certs_private_key_file_name', (v) => v as String),
+          iosFolderPath: $checkedConvert('ios_folder_path', (v) => v as String),
+          encryptedKeyFileName:
+              $checkedConvert('encrypted_key_file_name', (v) => v as String),
+          developerAppIdentifier:
+              $checkedConvert('developer_app_identifier', (v) => v as String),
+          teamName: $checkedConvert('team_name', (v) => v as String),
+          appleIssuerId: $checkedConvert('apple_issuer_id', (v) => v as String),
+          gitUrl: $checkedConvert('git_url', (v) => v as String),
+          gitPassphrase: $checkedConvert('git_passphrase', (v) => v as String),
+          developerAppId:
+              $checkedConvert('developer_app_id', (v) => v as String),
+          userName: $checkedConvert('user_name', (v) => v as String),
+          appleKeyId: $checkedConvert('apple_key_id', (v) => v as String),
+          teamId: $checkedConvert('team_id', (v) => v as String),
+          provisionningProfiles: $checkedConvert('provisionning_profiles',
+              (v) => Map<String, String>.from(v as Map)),
+          flutterArgs: $checkedConvert('flutter_args', (v) => v as String),
+          iosKeysFileName:
+              $checkedConvert('ios_keys_file_name', (v) => v as String),
+        );
+        return val;
+      },
+      fieldKeyMap: const {
+        'appleApiPrivateKeyFileName': 'apple_api_private_key_file_name',
+        'gitCertsPrivateKeyFileName': 'git_certs_private_key_file_name',
+        'iosFolderPath': 'ios_folder_path',
+        'encryptedKeyFileName': 'encrypted_key_file_name',
+        'developerAppIdentifier': 'developer_app_identifier',
+        'teamName': 'team_name',
+        'appleIssuerId': 'apple_issuer_id',
+        'gitUrl': 'git_url',
+        'gitPassphrase': 'git_passphrase',
+        'developerAppId': 'developer_app_id',
+        'userName': 'user_name',
+        'appleKeyId': 'apple_key_id',
+        'teamId': 'team_id',
+        'provisionningProfiles': 'provisionning_profiles',
+        'flutterArgs': 'flutter_args',
+        'iosKeysFileName': 'ios_keys_file_name'
+      },
+    );
+
+Map<String, dynamic> _$IosConfigToJson(IosConfig instance) => <String, dynamic>{
+      'flutter_args': instance.flutterArgs,
+      'ios_folder_path': instance.iosFolderPath,
+      'encrypted_key_file_name': instance.encryptedKeyFileName,
+      'apple_api_private_key_file_name': instance.appleApiPrivateKeyFileName,
+      'git_certs_private_key_file_name': instance.gitCertsPrivateKeyFileName,
+      'ios_keys_file_name': instance.iosKeysFileName,
+      'developer_app_id': instance.developerAppId,
+      'developer_app_identifier': instance.developerAppIdentifier,
+      'team_id': instance.teamId,
+      'team_name': instance.teamName,
+      'user_name': instance.userName,
+      'apple_issuer_id': instance.appleIssuerId,
+      'apple_key_id': instance.appleKeyId,
+      'git_passphrase': instance.gitPassphrase,
+      'git_url': instance.gitUrl,
+      'provisionning_profiles': instance.provisionningProfiles,
+    };

packages/wyatt_continuous_deployment/lib/src/domain/entities/decrypt_keys_parameters.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,4 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'base_remote_data_source.dart';
+class DecryptKeysParameters {
+  const DecryptKeysParameters({
+    required this.encryptedFilePath,
+    required this.passphrase,
+  });
+
+  final String encryptedFilePath;
+  final String passphrase;
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/entities.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,13 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'package:wyatt_architecture/src/domain/data_sources/base_data_source.dart';
-
-/// {@template base_remote_data_source}
-/// [BaseRemoteDataSource] is a base class for all remote data sources in the
-/// wyatt architecture.
-/// {@endtemplate}
-abstract class BaseRemoteDataSource extends BaseDataSource {
-  /// {@macro base_remote_data_source}
-  const BaseRemoteDataSource();
-}
+export 'config/android_config.dart';
+export 'config/appstore_connect_config.dart';
+export 'config/init_config_parameters.dart';
+export 'config/ios_config.dart';
+export 'decrypt_keys_parameters.dart';
+export 'fastlane.dart';
+export 'fastlane/fastlane_create_keychain_parameters.dart';
+export 'fastlane/fastlane_deploy_pilot_parameters.dart';
+export 'fastlane/fastlane_deploy_supply_parameters.dart';
+export 'fastlane/fastlane_get_certificates_parameters.dart';
+export 'flutter.dart';

packages/wyatt_continuous_deployment/lib/src/domain/entities/fastlane.dart

@@ -0,0 +1,68 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_create_keychain_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_deploy_pilot_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_deploy_supply_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_get_certificates_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_create_keychain_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_deploy_pilot_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_deploy_supply_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/fastlane/fastlane_get_certificates_usecase.dart';
+
+class Fastlane {
+  factory Fastlane() => Fastlane._(
+        createKeychainUsecase: getIt(),
+        deployPilotUsecase: getIt(),
+        deploySupplyUsecase: getIt(),
+        getCertificateUsecase: getIt(),
+      );
+
+  Fastlane._({
+    required FastlaneCreateKeychainUsecase createKeychainUsecase,
+    required FastlaneDeployPilotUsecase deployPilotUsecase,
+    required FastlaneDeploySupplyUsecase deploySupplyUsecase,
+    required FastlaneGetCertificateUsecase getCertificateUsecase,
+  })  : _createKeychainUsecase = createKeychainUsecase,
+        _deployPilotUsecase = deployPilotUsecase,
+        _deploySupplyUsecase = deploySupplyUsecase,
+        _getCertificateUsecase = getCertificateUsecase;
+
+  final FastlaneCreateKeychainUsecase _createKeychainUsecase;
+  final FastlaneDeployPilotUsecase _deployPilotUsecase;
+  final FastlaneDeploySupplyUsecase _deploySupplyUsecase;
+  final FastlaneGetCertificateUsecase _getCertificateUsecase;
+
+  FutureOrResult<void> createKeychain(
+    FastlaneCreateKeychainParameters params,
+  ) =>
+      _createKeychainUsecase(params);
+
+  FutureOrResult<void> deployAppStore(FastlaneDeployPilotParameters params) =>
+      _deployPilotUsecase(params);
+
+  FutureOrResult<void> deployGooglePlay(
+    FastlaneDeploySupplyParameters params,
+  ) =>
+      _deploySupplyUsecase(params);
+
+  FutureOrResult<void> getCertificates(
+    FastlaneGetCertificatesParameters params,
+  ) =>
+      _getCertificateUsecase(params);
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/fastlane/fastlane_create_keychain_parameters.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,13 +14,25 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import 'package:wyatt_architecture/src/domain/data_sources/base_data_source.dart';
+class FastlaneCreateKeychainParameters {
+  const FastlaneCreateKeychainParameters({
+    required this.name,
+    required this.password,
+    required this.gitPassphrase,
+    this.unlock = false,
+    this.timeout = 0,
+  });
 
-/// {@template base_local_data_source}
-/// [BaseLocalDataSource] is a base class for all local data sources in the
-/// wyatt architecture.
-/// {@endtemplate}
-abstract class BaseLocalDataSource extends BaseDataSource {
-  /// {@macro base_local_data_source}
-  const BaseLocalDataSource();
+  final String name;
+  final String password;
+  final String gitPassphrase;
+  final bool unlock;
+  final int timeout;
+
+  List<String> toList() => [
+        'name:$name',
+        'password:$password',
+        'unlock:$unlock',
+        'timeout:$timeout',
+      ];
 }

packages/wyatt_continuous_deployment/lib/src/domain/entities/fastlane/fastlane_deploy_pilot_parameters.dart

@@ -0,0 +1,49 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/appstore_connect_config.dart';
+
+class FastlaneDeployPilotParameters {
+  const FastlaneDeployPilotParameters({
+    required this.appStoreConnectConfig,
+    required this.developerAppId,
+    required this.developerAppIdentifier,
+    required this.ipaPath,
+    this.skipWaitingForBuildProcessing = true,
+    this.skipSubmission = true,
+    this.distributeExternal = false,
+    this.notifyExternalTesters = false,
+  });
+
+  final AppStoreConnectConfig appStoreConnectConfig;
+  final String developerAppId;
+  final String developerAppIdentifier;
+  final String ipaPath;
+  final bool skipWaitingForBuildProcessing;
+  final bool skipSubmission;
+  final bool distributeExternal;
+  final bool notifyExternalTesters;
+
+  List<String> toList() => [
+        'apple_id:$developerAppId',
+        'app_identifier:$developerAppIdentifier',
+        'ipa:$ipaPath',
+        'skip_waiting_for_build_processing:$skipWaitingForBuildProcessing',
+        'skip_submission:$skipSubmission',
+        'distribute_external:$distributeExternal',
+        'notify_external_testers:$notifyExternalTesters',
+      ];
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/fastlane/fastlane_deploy_supply_parameters.dart

@@ -0,0 +1,48 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+class FastlaneDeploySupplyParameters {
+  const FastlaneDeploySupplyParameters({
+    required this.track,
+    required this.serviceAccountPath,
+    required this.appBundlePath,
+    required this.releaseStatus,
+    required this.packageName,
+    this.skipUploadMetadata = true,
+    this.skipUploadImages = true,
+    this.skipUploadScreenshots = true,
+  });
+
+  final String track;
+  final String packageName;
+  final String serviceAccountPath;
+  final String appBundlePath;
+  final String releaseStatus;
+  final bool skipUploadMetadata;
+  final bool skipUploadImages;
+  final bool skipUploadScreenshots;
+
+  List<String> toList() => [
+        'track:$track',
+        'json_key:$serviceAccountPath',
+        'aab:$appBundlePath',
+        'release_status:$releaseStatus',
+        'package_name:$packageName',
+        'skip_upload_metadata:$skipUploadMetadata',
+        'skip_upload_images:$skipUploadImages',
+        'skip_upload_screenshots:$skipUploadScreenshots',
+      ];
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/fastlane/fastlane_get_certificates_parameters.dart

@@ -0,0 +1,51 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+class FastlaneGetCertificatesParameters {
+  const FastlaneGetCertificatesParameters({
+    required this.gitPrivateKey,
+    required this.appIdentifier,
+    required this.keychainName,
+    required this.keychainPassword,
+    required this.userName,
+    required this.teamId,
+    required this.teamName,
+    required this.gitUrl,
+    required this.gitPassphrase,
+  });
+
+  final String gitPrivateKey;
+  final String appIdentifier;
+  final String keychainName;
+  final String keychainPassword;
+  final String userName;
+  final String teamId;
+  final String teamName;
+  final String gitUrl;
+  final String gitPassphrase;
+
+  List<String> toList() => [
+        'app_identifier:$appIdentifier',
+        'git_private_key:$gitPrivateKey',
+        'keychain_name:$keychainName',
+        'keychain_password:$keychainPassword',
+        'username:$userName',
+        'team_id:$teamId',
+        'team_name:$teamName',
+        'git_url:$gitUrl',
+        'storage_mode:git',
+      ];
+}

packages/wyatt_continuous_deployment/lib/src/domain/entities/flutter.dart

@@ -0,0 +1,59 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_app_bundle_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_ipa_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_build_xcarchive_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_clean_usecase.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/flutter/flutter_pub_get_usecase.dart';
+
+class Flutter {
+  factory Flutter() => Flutter._(
+        flutterCleanUsecase: getIt(),
+        flutterPubGetUsecase: getIt(),
+        flutterBuildXcarchiveUsecase: getIt(),
+        flutterBuildIpaUsecase: getIt(),
+        flutterBuildAppBundleUsecase: getIt(),
+      );
+
+  Flutter._({
+    required FlutterCleanUsecase flutterCleanUsecase,
+    required FlutterPubGetUsecase flutterPubGetUsecase,
+    required FlutterBuildXcarchiveUsecase flutterBuildXcarchiveUsecase,
+    required FlutterBuildIpaUsecase flutterBuildIpaUsecase,
+    required FlutterBuildAppBundleUsecase flutterBuildAppBundleUsecase,
+  })  : _flutterCleanUsecase = flutterCleanUsecase,
+        _flutterPubGetUsecase = flutterPubGetUsecase,
+        _flutterBuildXcarchiveUsecase = flutterBuildXcarchiveUsecase,
+        _flutterBuildIpaUsecase = flutterBuildIpaUsecase,
+        _flutterBuildAppBundleUsecase = flutterBuildAppBundleUsecase;
+
+  final FlutterCleanUsecase _flutterCleanUsecase;
+  final FlutterPubGetUsecase _flutterPubGetUsecase;
+  final FlutterBuildXcarchiveUsecase _flutterBuildXcarchiveUsecase;
+  final FlutterBuildIpaUsecase _flutterBuildIpaUsecase;
+  final FlutterBuildAppBundleUsecase _flutterBuildAppBundleUsecase;
+
+  FutureOrResult<void> clean() => _flutterCleanUsecase();
+  FutureOrResult<void> getDependencies() => _flutterPubGetUsecase();
+  FutureOrResult<void> createXcArchive() => _flutterBuildXcarchiveUsecase();
+  FutureOrResult<void> buildIpa(List<String> args) =>
+      _flutterBuildIpaUsecase(args);
+  FutureOrResult<void> buildAppBundle(List<String> args) =>
+      _flutterBuildAppBundleUsecase(args);
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/config/get_android_config_usecase.dart

@@ -0,0 +1,40 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:checked_yaml/checked_yaml.dart';
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/android_config.dart';
+import 'package:yaml/yaml.dart';
+
+@usecase
+class GetAndroidConfigUsecase extends AsyncUseCase<String, AndroidConfig> {
+  const GetAndroidConfigUsecase() : super();
+
+  @override
+  FutureOr<Res<AndroidConfig>> execute(String params) => unsafe(() {
+        final file = File(params);
+        final content = file.readAsStringSync();
+
+        return checkedYamlDecode(
+          content,
+          (json) => AndroidConfig.fromJson(json!['android'] as YamlMap),
+        );
+      });
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/config/get_ios_config_usecase.dart

@@ -0,0 +1,40 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:checked_yaml/checked_yaml.dart';
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/ios_config.dart';
+import 'package:yaml/yaml.dart';
+
+@usecase
+class GetIosConfigUsecase extends AsyncUseCase<String, IosConfig> {
+  const GetIosConfigUsecase() : super();
+
+  @override
+  FutureOr<Res<IosConfig>> execute(String params) => unsafe(() {
+        final file = File(params);
+        final content = file.readAsStringSync();
+
+        return checkedYamlDecode(
+          content,
+          (json) => IosConfig.fromJson(json!['ios'] as YamlMap),
+        );
+      });
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/config/init_config_usecase.dart

@@ -0,0 +1,72 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/constants/app_constants.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/core/utils/logging.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/android_config.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/init_config_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/config/ios_config.dart';
+import 'package:yaml_edit/yaml_edit.dart';
+
+@usecase
+class InitConfigUsecase extends AsyncUseCase<InitConfigParameters, void> {
+  const InitConfigUsecase() : super();
+
+  @override
+  FutureOr<Res<void>> execute(InitConfigParameters params) => unsafe(() async {
+        final file = File(params.path);
+        if (!file.existsSync()) {
+          logger.detail('Creating config file at `${params.path}`');
+          file.createSync();
+        } else {
+          if (!params.force) {
+            throw ClientException(
+              'Config file already exists at `${params.path}`',
+            );
+          } else {
+            logger.detail('Forced to create config file at `${params.path}`');
+            file
+              ..deleteSync()
+              ..createSync();
+          }
+        }
+
+        const androidConfig = AndroidConfig.defaultValues;
+
+        logger.detail(
+          'Writing default android config: ${androidConfig.toJson()}',
+        );
+
+        const iosConfig = IosConfig.defaultValues;
+
+        logger.detail(
+          'Writing default ios config: ${iosConfig.toJson()}',
+        );
+
+        final yamlEditor = YamlEditor('')
+          ..update([], {
+            AppConstants.androidConfigKey: androidConfig.toJson(),
+            AppConstants.iosConfigKey: iosConfig.toJson(),
+          });
+
+        file.writeAsStringSync(yamlEditor.toString());
+      });
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/decrypt_keys/decrypt_keys_usecase.dart

@@ -0,0 +1,95 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/core/utils/logging.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/decrypt_keys_parameters.dart';
+
+@usecase
+class DecryptKeysUsecase extends AsyncUseCase<DecryptKeysParameters, void> {
+  const DecryptKeysUsecase() : super();
+
+  @override
+  FutureOr<void> onStart(DecryptKeysParameters? params) {
+    if (params == null) {
+      throw const ClientException('DecryptKeysParameters is null');
+    }
+    if (params.encryptedFilePath.isEmpty) {
+      throw const ClientException('Encrypted file path is empty');
+    }
+    if (!params.encryptedFilePath.endsWith('.gpg')) {
+      throw const ClientException('Enncrypted file is not a .gpg file');
+    }
+  }
+
+  @override
+  FutureOr<Res<void>> execute(DecryptKeysParameters params) => unsafe(() async {
+        // Define gpg command
+        final gpgFilePath =
+            params.encryptedFilePath.replaceAll(RegExp(r'\.gpg$'), '');
+        final outputGpgFilePath =
+            gpgFilePath.endsWith('.zip') ? gpgFilePath : '$gpgFilePath.zip';
+
+        final gpgCommand = 'gpg --quiet --batch --yes --decrypt '
+            '--passphrase=${params.passphrase} '
+            '--output $outputGpgFilePath ${params.encryptedFilePath}';
+
+        logger.detail(
+          '''DecryptKeysUsecase: Decrypting the file with the command: ${gpgCommand.replaceAll(params.passphrase, '*' * params.passphrase.length)}''',
+        );
+
+        final progress = logger.progress('Decrypting keys...');
+
+        // Verify if the command was executed successfully
+        final gpgResult = await Process.run('sh', ['-c', gpgCommand]);
+
+        logger.detail(gpgResult.stdout.toString());
+
+        if (gpgResult.exitCode == 0) {
+          // Move the extracted files to the current directory
+          final folder = Directory(outputGpgFilePath.replaceAll('.zip', ''));
+
+          progress.update('Unzipping...');
+
+          final unzipResult = await Process.run('sh', [
+            '-c',
+            'unzip -o $outputGpgFilePath -d ${folder.parent.path} && mv ${folder.path}/* ${folder.parent.path}',
+          ]);
+
+          logger.detail(unzipResult.stdout.toString());
+
+          if (unzipResult.exitCode != 0) {
+            progress.fail('Error during the unzip of the file');
+            throw ClientException(
+              'DecryptKeysUsecase: Error during the unzip '
+              'of the file : ${unzipResult.stderr}',
+            );
+          }
+
+          return progress.complete('Keys decrypted!');
+        } else {
+          progress.fail('Error during the decryption of the GPG file');
+          throw ClientException(
+            'DecryptKeysUsecase: Error during the decryption '
+            'of the GPG file : ${gpgResult.stderr}',
+          );
+        }
+      });
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/fastlane/fastlane_create_keychain_usecase.dart

@@ -0,0 +1,49 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_create_keychain_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FastlaneCreateKeychainUsecase
+    extends ProcessUsecase<FastlaneCreateKeychainParameters> {
+  @override
+  String get onCompletedMessage => 'Keychain created!';
+
+  @override
+  String get onErrorMessage => 'Error creating keychain!';
+
+  @override
+  String get onStartedMessage => 'Creating keychain...';
+
+  @override
+  Future<ProcessResult?> run(FastlaneCreateKeychainParameters param) =>
+      Process.run(
+        'fastlane',
+        [
+          'run',
+          'create_keychain',
+          ...param.toList(),
+        ],
+        environment: {
+          'MATCH_PASSWORD': param.gitPassphrase,
+        },
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/fastlane/fastlane_deploy_pilot_usecase.dart

@@ -0,0 +1,55 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/core/utils/logging.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_deploy_pilot_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FastlaneDeployPilotUsecase
+    extends ProcessUsecase<FastlaneDeployPilotParameters> {
+  @override
+  String get onCompletedMessage => 'Ipa deployed!';
+
+  @override
+  String get onErrorMessage => 'Error deploying ipa!';
+
+  @override
+  String get onStartedMessage => 'Deploying ipa...';
+
+  @override
+  Future<ProcessResult?> run(FastlaneDeployPilotParameters param) async {
+    final file = File(param.appStoreConnectConfig.keyFilePath!);
+    final content = file.readAsBytesSync();
+    final key = utf8.decode(content);
+
+    const executable = 'fastlane';
+    final args = [
+      'run',
+      'pilot',
+      'api_key:${jsonEncode(param.appStoreConnectConfig.toJson(key))}',
+      ...param.toList(),
+    ];
+
+    logger.detail('Running: $executable ${args.join(' ')}');
+
+    return Process.run(executable, args);
+  }
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/fastlane/fastlane_deploy_supply_usecase.dart

@@ -0,0 +1,45 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_deploy_supply_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FastlaneDeploySupplyUsecase
+    extends ProcessUsecase<FastlaneDeploySupplyParameters> {
+  @override
+  String get onCompletedMessage => 'Aab deployed!';
+
+  @override
+  String get onErrorMessage => 'Error deploying aab!';
+
+  @override
+  String get onStartedMessage => 'Deploying aab...';
+
+  @override
+  Future<ProcessResult?> run(FastlaneDeploySupplyParameters param) =>
+      Process.run(
+        'fastlane',
+        [
+          'run',
+          'supply',
+          ...param.toList(),
+        ],
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/fastlane/fastlane_get_certificates_usecase.dart

@@ -0,0 +1,49 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/entities/fastlane/fastlane_get_certificates_parameters.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FastlaneGetCertificateUsecase
+    extends ProcessUsecase<FastlaneGetCertificatesParameters> {
+  @override
+  String get onCompletedMessage => 'Certificates fetched!';
+
+  @override
+  String get onErrorMessage => 'Error fetching certificates!';
+
+  @override
+  String get onStartedMessage => 'Fetching certificates...';
+
+  @override
+  Future<ProcessResult?> run(FastlaneGetCertificatesParameters param) =>
+      Process.run(
+        'fastlane',
+        [
+          'run',
+          'match',
+          'type:appstore',
+          ...param.toList(),
+        ],
+        environment: {
+          'MATCH_PASSWORD': param.gitPassphrase,
+        },
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/find_last_ipa_file_usecase.dart

@@ -0,0 +1,50 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/core/utils/logging.dart';
+import 'package:wyatt_type_utils/wyatt_type_utils.dart';
+
+@usecase
+class FindLastIpaFileUsecase extends AsyncUseCase<String, String> {
+  const FindLastIpaFileUsecase() : super();
+
+  @override
+  FutureOrResult<String> execute(String params) {
+    final Directory directory = Directory(params);
+
+    if (!directory.existsSync()) {
+      logger.detail('No IPA file found in $params');
+      return Err(ClientException('Directory not found: $params'));
+    }
+
+    final List<FileSystemEntity> files = directory.listSync()
+      ..sort((a, b) => b.statSync().modified.compareTo(a.statSync().modified));
+
+    for (final FileSystemEntity file in files) {
+      if (file.path.endsWith('.ipa')) {
+        logger.detail('Found IPA file: ${file.path}');
+        return Ok(file.path);
+      }
+    }
+
+    logger.detail('No IPA file found in $params');
+    return Err(ClientException('No IPA file found in $params'));
+  }
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/flutter/flutter_build_app_bundle_usecase.dart

@@ -0,0 +1,43 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FlutterBuildAppBundleUsecase extends ProcessUsecase<List<String>> {
+  const FlutterBuildAppBundleUsecase();
+
+  @override
+  String get onCompletedMessage => 'App bundle built!';
+
+  @override
+  String get onErrorMessage => 'Error building app bundle!';
+
+  @override
+  String get onStartedMessage => 'Building app bundle...';
+
+  @override
+  Future<ProcessResult?> run(
+    List<String> param,
+  ) =>
+      Process.run(
+        'flutter',
+        ['build', 'appbundle', '--release', ...param],
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/flutter/flutter_build_ipa_usecase.dart

@@ -0,0 +1,43 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FlutterBuildIpaUsecase extends ProcessUsecase<List<String>> {
+  const FlutterBuildIpaUsecase();
+
+  @override
+  String get onCompletedMessage => 'Ipa built!';
+
+  @override
+  String get onErrorMessage => 'Error building ipa!';
+
+  @override
+  String get onStartedMessage => 'Building ipa...';
+
+  @override
+  Future<ProcessResult?> run(
+    List<String> param,
+  ) =>
+      Process.run(
+        'flutter',
+        ['build', 'ipa', '--release', ...param],
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/flutter/flutter_build_xcarchive_usecase.dart

@@ -0,0 +1,40 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FlutterBuildXcarchiveUsecase extends ProcessNoParamsUsecase {
+  const FlutterBuildXcarchiveUsecase();
+
+  @override
+  String get onCompletedMessage => 'Xcarchive built!';
+
+  @override
+  String get onErrorMessage => 'Error building xcarchive!';
+
+  @override
+  String get onStartedMessage => 'Building xcarchive...';
+
+  @override
+  Future<ProcessResult?> run() => Process.run(
+        'flutter',
+        ['build', 'xcarchive', '--no-codesign', '-v'],
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/flutter/flutter_clean_usecase.dart

@@ -0,0 +1,40 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FlutterCleanUsecase extends ProcessNoParamsUsecase {
+  const FlutterCleanUsecase();
+
+  @override
+  String get onCompletedMessage => 'Project cleaned!';
+
+  @override
+  String get onErrorMessage => 'Error cleaning project!';
+
+  @override
+  String get onStartedMessage => 'Cleaning project...';
+
+  @override
+  Future<ProcessResult?> run() => Process.run(
+        'flutter',
+        ['clean'],
+      );
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/flutter/flutter_pub_get_usecase.dart

@@ -0,0 +1,37 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+import 'package:wyatt_continuous_deployment/src/domain/usecases/process_usecase.dart';
+
+@usecase
+class FlutterPubGetUsecase extends ProcessNoParamsUsecase {
+  const FlutterPubGetUsecase();
+
+  @override
+  String get onCompletedMessage => 'Dependencies got!';
+
+  @override
+  String get onErrorMessage => 'Error getting dependencies!';
+
+  @override
+  String get onStartedMessage => 'Getting dependencies...';
+
+  @override
+  Future<ProcessResult?> run() => Process.run('flutter', ['pub', 'get']);
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/process_usecase.dart

@@ -0,0 +1,93 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/utils/logging.dart';
+
+abstract class ProcessUsecase<T> extends AsyncUseCase<T, void> {
+  const ProcessUsecase();
+
+  /// If true, the process will not throw an exception if the exit
+  /// code is not 0.
+  /// This is useful for commands that may return a non-zero exit code.
+  /// For example, `git diff` returns 1 if there are differences.
+  bool get ignoreOnFailure => false;
+
+  String get onStartedMessage;
+
+  String get onCompletedMessage;
+
+  String get onErrorMessage;
+
+  @override
+  FutureOr<Res<void>> execute(T params) async {
+    final progress = logger.progress(onStartedMessage);
+    final processResult = await run(params);
+    if (processResult != null) {
+      if (processResult.exitCode != 0) {
+        progress.fail(onErrorMessage);
+      }
+      if (processResult.exitCode != 0 && !ignoreOnFailure) {
+        throw ClientException(processResult.stderr.toString());
+      }
+    }
+    progress.complete(onCompletedMessage);
+    logger.detail(processResult?.stdout.toString().trim());
+    return Res.ok(null);
+  }
+
+  /// Run the process with the given parameters.
+  Future<ProcessResult?> run(T param);
+}
+
+abstract class ProcessNoParamsUsecase extends NoParamsAsyncUseCase<void> {
+  const ProcessNoParamsUsecase() : super();
+
+  /// If true, the process will not throw an exception if the exit
+  /// code is not 0.
+  /// This is useful for commands that may return a non-zero exit code.
+  /// For example, `git diff` returns 1 if there are differences.
+  bool get ignoreOnFailure => false;
+
+  String get onStartedMessage;
+
+  String get onCompletedMessage;
+
+  String get onErrorMessage;
+
+  @override
+  FutureOr<Res<void>> execute() async {
+    final progress = logger.progress(onStartedMessage);
+    final processResult = await run();
+    if (processResult != null) {
+      if (processResult.exitCode != 0) {
+        progress.fail(onErrorMessage);
+      }
+      if (processResult.exitCode != 0 && !ignoreOnFailure) {
+        throw ClientException(processResult.stderr.toString());
+      }
+    }
+    progress.complete(onCompletedMessage);
+    logger.detail(processResult?.stdout.toString().trim());
+    return Res.ok(null);
+  }
+
+  /// Run the process with no parameters.
+  Future<ProcessResult?> run();
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/requirements/check_config_file_usecase.dart

@@ -0,0 +1,35 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+
+@usecase
+class CheckConfigFileUsecase extends AsyncUseCase<String, void> {
+  const CheckConfigFileUsecase() : super();
+
+  @override
+  FutureOrResult<void> execute(String params) => unsafe(() {
+        final configFile = File(params);
+        if (!configFile.existsSync()) {
+          throw ClientException(
+            'CheckConfigFileUsecase: Cannot find $params',
+          );
+        }
+      });
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/requirements/check_tools_usecase.dart

@@ -0,0 +1,50 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:wyatt_architecture/wyatt_architecture.dart';
+import 'package:wyatt_continuous_deployment/src/core/constants/app_constants.dart';
+import 'package:wyatt_continuous_deployment/src/core/injection/injectable.dart';
+
+@usecase
+class CheckToolsUsecase extends NoParamsAsyncUseCase<void> {
+  const CheckToolsUsecase() : super();
+
+  @override
+  FutureOr<Res<void>> execute() async => unsafe(() async {
+        final missingTools = <String>[];
+        for (final tool in AppConstants.requiredTools) {
+          final isInstalled = await checkToolInstalled(tool);
+          if (!isInstalled) {
+            missingTools.add(tool);
+          }
+        }
+
+        if (missingTools.isNotEmpty) {
+          throw ClientException(
+            'CheckToolsUsecase: Missing ${missingTools.join(' - ')}',
+          );
+        }
+      });
+
+  Future<bool> checkToolInstalled(String tool) async {
+    final result = await Process.run('which', [tool]);
+
+    return result.exitCode == 0 && (result.stdout as String).trim().isNotEmpty;
+  }
+}

packages/wyatt_continuous_deployment/lib/src/domain/usecases/usecases.dart

@@ -0,0 +1,33 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+export 'config/get_android_config_usecase.dart';
+export 'config/get_ios_config_usecase.dart';
+export 'config/init_config_usecase.dart';
+export 'decrypt_keys/decrypt_keys_usecase.dart';
+export 'fastlane/fastlane_create_keychain_usecase.dart';
+export 'fastlane/fastlane_deploy_pilot_usecase.dart';
+export 'fastlane/fastlane_deploy_supply_usecase.dart';
+export 'fastlane/fastlane_get_certificates_usecase.dart';
+export 'find_last_ipa_file_usecase.dart';
+export 'flutter/flutter_build_app_bundle_usecase.dart';
+export 'flutter/flutter_build_ipa_usecase.dart';
+export 'flutter/flutter_build_xcarchive_usecase.dart';
+export 'flutter/flutter_clean_usecase.dart';
+export 'flutter/flutter_pub_get_usecase.dart';
+export 'process_usecase.dart';
+export 'requirements/check_config_file_usecase.dart';
+export 'requirements/check_tools_usecase.dart';

packages/wyatt_continuous_deployment/lib/src/wyatt_continuous_deployment.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,4 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'base_local_data_source.dart';
+import 'package:mason_logger/mason_logger.dart';
+
+export 'domain/domain.dart';
+
+abstract class WyattContinuousDeployment {
+  static Logger logger = Logger();
+}

packages/wyatt_continuous_deployment/lib/wyatt_continuous_deployment.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-export 'base_data_source.dart';
-export 'local/local.dart';
-export 'remote/remote.dart';
+/// Wyatt CD
+library wyatt_continuous_deployment;
+
+export 'src/wyatt_continuous_deployment.dart';

packages/wyatt_continuous_deployment/pubspec.yaml

@@ -0,0 +1,36 @@
+name: wyatt_continuous_deployment
+description: Wyatt CD.
+repository: https://git.wyatt-studio.fr/Wyatt-FOSS/wyatt-packages/src/branch/master/packages/wyatt_continuous_deployment
+version: 1.0.0
+
+publish_to: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+
+dependencies:
+  checked_yaml: ^2.0.3
+  get_it: ^7.6.7
+  injectable: ^2.3.2
+  json_annotation: ^4.8.1
+  mason_logger: ^0.2.12
+  wyatt_architecture:
+    hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub/
+    version: ^0.2.0+1
+  wyatt_type_utils:
+    hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
+    version: ^0.0.5
+  yaml: ^3.1.2
+  yaml_edit: ^2.1.1
+
+dev_dependencies:
+  build_runner: ^2.4.8
+  dart_code_linter: ^1.1.1
+
+  injectable_generator: ^2.4.1
+  json_serializable: ^6.7.1
+  test: ^1.21.0
+
+  wyatt_analysis:
+    hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
+    version: ^2.6.1

packages/wyatt_continuous_deployment/test/wyatt_continuous_deployment_test.dart

@@ -0,0 +1 @@
+// TODO(wyatt): add some tests

packages/wyatt_type_utils/lib/src/either/either_base.dart

@@ -1,26 +1,21 @@
-// // Copyright (C) 2022 WYATT GROUP
-// // Please see the AUTHORS file for details.
-// //
-// // This program is free software: you can redistribute it and/or modify
-// // it under the terms of the GNU General Public License as published by
-// // the Free Software Foundation, either version 3 of the License, or
-// // any later version.
-// //
-// // This program is distributed in the hope that it will be useful,
-// // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// // GNU General Public License for more details.
-// //
-// // You should have received a copy of the GNU General Public License
-// // along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-// // ignore_for_file: avoid_positional_boolean_parameters
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 import 'dart:async';
 
-part 'future_result.dart';
-part 'future_or_result.dart';
-part 'result.dart';
 part 'option.dart';
 
 mixin _Left<LeftType, RightType> on _EitherBase<LeftType, RightType> {}
@@ -35,7 +30,9 @@ class _EitherBaseException implements Exception {
   String toString() => '_EitherException: $message';
 }
 
+@Deprecated('Use Dart pattern matching instead')
 abstract class _EitherBase<LeftType, RightType> {
+  @Deprecated('Use Dart pattern matching instead')
   const _EitherBase();
 
   bool get _isLeft => this is _Left<LeftType, RightType>;
@@ -56,20 +53,20 @@ abstract class _EitherBase<LeftType, RightType> {
     if (U == LeftType) {
       return _fold<LeftType>(
         (value) => value,
-        (right) => throw const ResultException(
+        (right) => throw Exception(
           'Illegal use. You should check left value before calling',
         ),
       ) as U;
     }
     if (U == RightType) {
       return _fold<RightType>(
-        (left) => throw const ResultException(
+        (left) => throw Exception(
           'Illegal use. You should check right value before calling',
         ),
         (value) => value,
       ) as U;
     }
-    throw ResultException(
+    throw Exception(
       'Illegal use. You should use $LeftType or $RightType type',
     );
   }
@@ -78,20 +75,20 @@ abstract class _EitherBase<LeftType, RightType> {
     if (U == LeftType) {
       return _foldAsync<LeftType>(
         Future.value,
-        (right) => throw const ResultException(
+        (right) => throw Exception(
           'Illegal use. You should check left value before calling',
         ),
       ) as Future<U>;
     }
     if (U == RightType) {
       return _foldAsync<RightType>(
-        (left) => throw const ResultException(
+        (left) => throw Exception(
           'Illegal use. You should check right value before calling',
         ),
         Future.value,
       ) as Future<U>;
     }
-    throw ResultException(
+    throw Exception(
       'Illegal use. You should use $LeftType or $RightType type',
     );
   }

packages/wyatt_type_utils/lib/src/either/option.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -41,8 +41,10 @@ class OptionException extends _EitherBaseException {
 /// if value not present) and ifPresent() (execute a block of code if the
 /// value is present).
 /// {@endtemplate}
+@Deprecated('Use Dart pattern matching instead')
 abstract class Option<T> extends _EitherBase<T, void> {
   /// {@macro option}
+  @Deprecated('Use Dart pattern matching instead')
   const Option._();
 
   /// Represents the left side of [Option] class.

packages/wyatt_type_utils/lib/src/either/result.dart

@@ -1,325 +0,0 @@
-// Copyright (C) 2022 WYATT GROUP
-// Please see the AUTHORS file for details.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-// ignore_for_file: avoid_positional_boolean_parameters
-
-part of 'either_base.dart';
-
-/// {@template result_exception}
-/// [ResultException] is sometimes threw by [Result] objects.
-///
-/// ```dart
-/// throw ResultException('Emergency failure!');
-/// ```
-/// {@endtemplate}
-class ResultException extends _EitherBaseException {
-  /// {@macro result_exception}
-  const ResultException(super.message);
-
-  @override
-  String toString() => 'ResultException: $message';
-}
-
-/// {@template result}
-/// [Result] type is coming from functional languages where exceptions are
-/// (rightfully) considered a side-effect, and therefore not appropriate to
-/// pass domain errors. Mind the difference between different kinds of errors:
-/// Some of them belong to domain, others don't.
-///
-/// *E.g. null reference exception or index out of bounds
-/// are not related to domain - they rather indicate a defect.*
-///
-/// Either is defined as a generic type with two branches
-/// - success with [T]
-/// - failure with [E]
-///
-/// It can appear in two forms, where
-/// it contains an object of [Ok], or where it contains an object
-/// of [Err]. It cannot appear in both states at once, or in none of them.
-/// Therefore, if one possesses an [Result] instance, it either contains a
-/// successfully produced result, or contains an error object.
-/// {@endtemplate}
-abstract class Result<T, E> extends _EitherBase<T, E> {
-  /// {@macro result}
-  const Result._();
-
-  /// Represents the left side of [Result] class.
-  bool get isOk => _isLeft;
-
-  /// Represents the right side of [Result] class.
-  bool get isErr => _isRight;
-
-  /// Get nullable [Ok] value, and discarding the error, if any.
-  T? get ok => _left;
-
-  /// Get nullable [Err] value, and discarding the success value, if any.
-  E? get err => _right;
-
-  /// Get [U] value, may throw an exception.
-  U unwrap<U>() => _unwrap<U>();
-
-  /// Get **async** [U] value, may throw an exception.
-  Future<U> unwrapAsync<U>() => _unwrapAsync<U>();
-
-  /// Fold [Ok] and [Err] into the value of one type
-  U fold<U>(
-    U Function(T value) valueTransformer,
-    U Function(E error) errorTransformer,
-  ) =>
-      _fold(
-        (left) => valueTransformer(left),
-        (right) => errorTransformer(right),
-      );
-
-  /// Fold [Ok] and [Err] **asynchronously** into the value of one type
-  Future<U> foldAsync<U>(
-    Future<U> Function(T value) valueTransformer,
-    Future<U> Function(E error) errorTransformer,
-  ) =>
-      _foldAsync(
-        (left) => valueTransformer(left),
-        (right) => errorTransformer(right),
-      );
-
-  /// Swap [Ok] and [Err]
-  Result<E, T> swap() => fold(Err.new, Ok.new);
-
-  /// Returns [res] if the [Result] is [Ok], otherwise returns
-  /// the [Err] value of this.
-  Result<U, E> and<U>(Result<U, E> res) => _and<U>(res) as Result<U, E>;
-
-  /// Returns [res] if the [Result] is [Err], otherwise returns
-  /// the [Ok] value of this.
-  Result<T, F> or<F>(Result<T, F> res) => _or<F>(res) as Result<T, F>;
-
-  /// Returns true if the result is an [Ok] or [Err] value containing
-  /// the given value/error.
-  bool contains<U>(U x) => _contains(x);
-
-  /// Returns the contained [Ok] value. Throw [ResultException] on [Err] with
-  /// its content.
-  T expect(String msg) => _expect(msg);
-
-  /// Returns the contained [Err] value. Throw [ResultException] on [Ok] with
-  /// its content.
-  E expectErr(String msg) => _expectErr(msg);
-
-  /// Maps a [Result<T, E>] to [Result<U, E>] by applying a function to a
-  /// contained [Ok] value, leaving an [Err] value untouched.
-  Result<U, E> map<U>(U Function(T value) mapper) =>
-      _map(mapper) as Result<U, E>;
-
-  /// Maps a [Result<T, E>] to [Result<U, E>] by applying an **async** function
-  /// to a contained [Ok] value, leaving an [Err] value untouched.
-  Future<Result<U, E>> mapAsync<U>(Future<U> Function(T value) mapper) =>
-      _mapAsync(mapper) as Future<Result<U, E>>;
-
-  /// Maps a [Result<T, E>] to [Result<T, F>] by applying a function to a
-  /// contained [Err] value, leaving an [Ok] value untouched.
-  Result<T, F> mapErr<F>(F Function(E error) mapper) =>
-      _mapErr(mapper) as Result<T, F>;
-
-  /// Maps a [Result<T, E>] to [Result<U, E>] by applying an **async** function
-  /// to a contained [Err] value, leaving an [Ok] value untouched.
-  Future<Result<T, F>> mapErrAsync<F>(Future<F> Function(E error) mapper) =>
-      _mapErrAsync(mapper) as Future<Result<T, F>>;
-
-  /// Transforms a [Result<T, E>] to [Result<U, F>] by applying functions to
-  /// contained [Ok] and [Err] values.
-  Result<U, F> either<U, F>(
-    U Function(T value) valueTransformer,
-    F Function(E error) errorTransformer,
-  ) =>
-      _either<U, F>(valueTransformer, errorTransformer) as Result<U, F>;
-
-  /// Transforms a [Result<T, E>] to [Result<U, F>] by applying **async**
-  /// functions to contained [Ok] and [Err] values.
-  Future<Result<U, F>> eitherAsync<U, F>(
-    Future<U> Function(T value) valueTransformer,
-    Future<F> Function(E error) errorTransformer,
-  ) =>
-      _eitherAsync<U, F>(valueTransformer, errorTransformer)
-          as Future<Result<U, F>>;
-
-  /// Constructs a new [Result] from a function that might throw
-  static Result<T, E> tryCatch<T, E, Error extends Object>(
-    T Function() tryFn,
-    E Function(Error error) onError,
-  ) {
-    try {
-      return Ok(tryFn());
-    } on Error catch (e) {
-      return Err(onError(e));
-    }
-  }
-
-  /// Constructs a new [Result] from an **async** function that might throw
-  static Future<Result<T, E>> tryCatchAsync<T, E, Error extends Object>(
-    Future<T> Function() tryFn,
-    E Function(Error error) onError,
-  ) async {
-    try {
-      return Ok(await tryFn());
-    } on Error catch (e) {
-      return Err(onError(e));
-    }
-  }
-
-  /// If the condition is satify then return [value] in
-  /// [Ok] else [error] in [Err]
-  static Result<T, E> conditional<T, E>(
-    bool test,
-    T value,
-    E error,
-  ) =>
-      test ? Ok(value) : Err(error);
-
-  /// If the condition is satify then return *command* [value]
-  /// in [Ok] else [error] in [Err]
-  static Result<T, E> conditionalLazy<T, E>(
-    bool test,
-    T Function() value,
-    E Function() error,
-  ) =>
-      test ? Ok(value()) : Err(error());
-}
-
-/// {@template ok}
-/// Contains the success value of a [Result]
-///
-/// {@macro result}
-/// {@endtemplate}
-class Ok<T, E> extends Result<T, E> with _Left<T, E> {
-  /// {@macro ok}
-  const Ok(this.value) : super._();
-  final T value;
-
-  @override
-  U _fold<U>(U Function(T left) fnL, U Function(E right) fnR) => fnL(value);
-
-  @override
-  Future<U> _foldAsync<U>(
-    Future<U> Function(T left) fnL,
-    Future<U> Function(E right) fnR,
-  ) =>
-      fnL(value);
-
-  @override
-  Result<U, E> _and<U>(_EitherBase<U, E> res) => res as Result<U, E>;
-
-  @override
-  Result<T, F> _or<F>(_EitherBase<T, F> res) => this as Result<T, F>;
-
-  @override
-  bool _contains<U>(U x) => value == x;
-
-  @override
-  T _expect(String msg) => value;
-
-  @override
-  E _expectErr(String msg) => throw ResultException('$msg: $value');
-
-  @override
-  Result<U, E> _map<U>(U Function(T value) mapper) => Ok(mapper(value));
-
-  @override
-  Future<Result<U, E>> _mapAsync<U>(Future<U> Function(T value) mapper) =>
-      mapper(value).then(Ok.new);
-
-  @override
-  Result<T, F> _mapErr<F>(F Function(E error) mapper) => Ok(value);
-
-  @override
-  Future<Result<T, F>> _mapErrAsync<F>(Future<F> Function(E error) mapper) =>
-      Future.value(Ok(value));
-
-  @override
-  Result<U, F> _either<U, F>(
-    U Function(T value) fnL,
-    F Function(E error) fnR,
-  ) =>
-      Ok(fnL(value));
-
-  @override
-  Future<Result<U, F>> _eitherAsync<U, F>(
-    Future<U> Function(T value) fnL,
-    Future<F> Function(E error) fnR,
-  ) =>
-      fnL(value).then(Ok.new);
-}
-
-/// {@template err}
-/// Contains the error value of a [Result]
-///
-/// {@macro result}
-/// {@endtemplate}
-class Err<T, E> extends Result<T, E> with _Right<T, E> {
-  /// {@macro err}
-  const Err(this.error) : super._();
-  final E error;
-
-  @override
-  U _fold<U>(U Function(T left) fnL, U Function(E right) fnR) => fnR(error);
-
-  @override
-  Future<U> _foldAsync<U>(
-    Future<U> Function(T left) fnL,
-    Future<U> Function(E right) fnR,
-  ) =>
-      fnR(error);
-
-  @override
-  Result<U, E> _and<U>(_EitherBase<U, E> res) => this as Result<U, E>;
-  @override
-  Result<T, F> _or<F>(_EitherBase<T, F> res) => res as Result<T, F>;
-
-  @override
-  bool _contains<U>(U x) => error == x;
-
-  @override
-  T _expect(String msg) => throw ResultException('$msg: $error');
-
-  @override
-  E _expectErr(String msg) => error;
-
-  @override
-  Result<U, E> _map<U>(U Function(T value) mapper) => Err(error);
-
-  @override
-  Future<Result<U, E>> _mapAsync<U>(Future<U> Function(T value) mapper) =>
-      Future.value(Err(error));
-
-  @override
-  Result<T, F> _mapErr<F>(F Function(E error) mapper) => Err(mapper(error));
-
-  @override
-  Future<Result<T, F>> _mapErrAsync<F>(Future<F> Function(E error) mapper) =>
-      mapper(error).then(Err.new);
-
-  @override
-  Result<U, F> _either<U, F>(
-    U Function(T value) fnL,
-    F Function(E error) fnR,
-  ) =>
-      Err(fnR(error));
-
-  @override
-  Future<Result<U, F>> _eitherAsync<U, F>(
-    Future<U> Function(T value) fnL,
-    Future<F> Function(E error) fnR,
-  ) =>
-      fnR(error).then(Err.new);
-}

packages/wyatt_type_utils/lib/src/extensions/iterable_extension.dart

@@ -37,13 +37,10 @@ extension IterableIntExtension on Iterable<int>? {
     switch (to) {
       case Encoding.utf8:
         str = utf8.decode(this?.toList() ?? []);
-        break;
       case Encoding.utf16:
         str = String.fromCharCodes(this ?? []);
-        break;
       case Encoding.base64:
         str = base64.encode(this?.toList() ?? []);
-        break;
       case Encoding.base16:
         str = List.generate(
           (this ?? []).length,

packages/wyatt_type_utils/lib/src/extensions/string_extension.dart

@@ -33,13 +33,10 @@ extension StringExtension on String? {
     switch (from) {
       case Encoding.utf8:
         bytes = utf8.encode(this ?? '').toTypedList();
-        break;
       case Encoding.utf16:
         bytes = (this ?? '').runes.toList().toTypedList();
-        break;
       case Encoding.base64:
         bytes = base64.decode(this ?? '');
-        break;
       case Encoding.base16:
         assert(
           (this ?? '').length.isEven,

packages/wyatt_type_utils/lib/src/pair/pair.dart

@@ -21,8 +21,10 @@ extension PairExtension<T> on Pair<T, T> {
 /// {@template pair}
 /// [Pair] is a simple object which contains pair of two values.
 /// {@endtemplate}
+@Deprecated('Use Dart built-in record type instead')
 class Pair<L, R> {
   /// {@macro pair}
+  @Deprecated('Use Dart built-in record type instead')
   const Pair(this.left, this.right);
   final L? left;
   final R? right;

packages/wyatt_type_utils/lib/src/result/future_or_result.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,7 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-part of 'either_base.dart';
+import 'dart:async';
+
+import 'package:wyatt_type_utils/src/result/result.dart';
 
 extension FutureOrResultExtension<T, E> on FutureOr<Result<T, E>> {
   /// Represents the left side of [Result] class.
@@ -72,13 +74,13 @@ extension FutureOrResultExtension<T, E> on FutureOr<Result<T, E>> {
   Future<bool> contains<U>(U x) =>
       Future.value(this).then((result) => result.contains(x));
 
-  /// Returns the contained [Ok] value. Throw [ResultException] on [Err] with
-  /// its content.
+  /// Returns the contained [Ok] value. Throw [ResultException] on
+  /// [Err] with its content.
   Future<T> expect(String msg) =>
       Future.value(this).then((result) => result.expect(msg));
 
-  /// Returns the contained [Err] value. Throw [ResultException] on [Ok] with
-  /// its content.
+  /// Returns the contained [Err] value. Throw [ResultException] on
+  /// [Ok] with its content.
   Future<E> expectErr(String msg) =>
       Future.value(this).then((result) => result.expectErr(msg));
 

packages/wyatt_type_utils/lib/src/result/future_result.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-part of 'either_base.dart';
+import 'package:wyatt_type_utils/src/result/result.dart';
 
 extension FutureResultExtension<T, E> on Future<Result<T, E>> {
   /// Represents the left side of [Result] class.
@@ -62,12 +62,12 @@ extension FutureResultExtension<T, E> on Future<Result<T, E>> {
   /// the given value/error.
   Future<bool> contains<U>(U x) => then((result) => result.contains(x));
 
-  /// Returns the contained [Ok] value. Throw [ResultException] on [Err] with
-  /// its content.
+  /// Returns the contained [Ok] value. Throw [ResultException] on
+  /// [Err] with its content.
   Future<T> expect(String msg) => then((result) => result.expect(msg));
 
-  /// Returns the contained [Err] value. Throw [ResultException] on [Ok] with
-  /// its content.
+  /// Returns the contained [Err] value. Throw [ResultException] on
+  /// [Ok] with its content.
   Future<E> expectErr(String msg) => then((result) => result.expectErr(msg));
 
   /// Maps a [Result<T, E>] to [Result<U, E>] by applying a function to a

packages/wyatt_type_utils/lib/src/result/result.dart

@@ -0,0 +1,346 @@
+// Copyright (C) 2024 WYATT GROUP
+// Please see the AUTHORS file for details.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+// ignore_for_file: avoid_equals_and_hash_code_on_mutable_classes
+
+import 'package:sealed_result/sealed_result.dart' as sealed;
+
+export 'future_or_result.dart';
+export 'future_result.dart';
+
+class ResultException extends sealed.ResultException {
+  const ResultException(String super.message);
+}
+
+/// {@template result}
+/// [Result] type is coming from functional languages where exceptions are
+/// (rightfully) considered a side-effect, and therefore not appropriate to
+/// pass domain errors. Mind the difference between different kinds of errors:
+/// Some of them belong to domain, others don't.
+///
+/// *E.g. null reference exception or index out of bounds
+/// are not related to domain - they rather indicate a defect.*
+///
+/// Either is defined as a generic type with two branches
+/// - success with [Success]
+/// - failure with [Failure]
+///
+/// It can appear in two forms, where
+/// it contains an object of [Ok], or where it contains an object
+/// of [Err]. It cannot appear in both states at once, or in none of them.
+/// Therefore, if one possesses an [Result] instance, it either contains a
+/// successfully produced result, or contains an error object.
+/// {@endtemplate}
+class Result<Success, Failure> {
+  /// {@macro result}
+  const Result._(this._result);
+
+  factory Result.ok(Success value) => Ok(value);
+  factory Result.err(Failure value) => Err(value);
+  factory Result.error(Failure value) => Err(value);
+  factory Result.success(Success value) => Ok(value);
+  factory Result.failure(Failure value) => Err(value);
+
+  final sealed.Result<Success, Failure> _result;
+
+  /// Represents the left side of [Result] class.
+  bool get isOk => _result.isOk;
+
+  /// Represents the right side of [Result] class.
+  bool get isErr => _result.isErr;
+
+  /// Get nullable [Ok] value, and discarding the error, if any.
+  Success? get ok => _result.ok;
+
+  /// Get nullable [Err] value, and discarding the success value, if any.
+  Failure? get err => _result.err;
+
+  /// Get [U] value, may throw an exception.
+  U unwrap<U>() {
+    if (U == Success) {
+      return fold<Success>(
+        (value) => value,
+        (right) => throw const ResultException(
+          'Illegal use. You should check left value before calling',
+        ),
+      ) as U;
+    }
+    if (U == Failure) {
+      return fold<Failure>(
+        (left) => throw const ResultException(
+          'Illegal use. You should check right value before calling',
+        ),
+        (value) => value,
+      ) as U;
+    }
+    throw ResultException(
+      'Illegal use. You should use $Success or $Failure type',
+    );
+  }
+
+  /// Get **async** [U] value, may throw an exception.
+  Future<U> unwrapAsync<U>() {
+    if (U == Success) {
+      return foldAsync<Success>(
+        Future.value,
+        (right) => throw const ResultException(
+          'Illegal use. You should check left value before calling',
+        ),
+      ) as Future<U>;
+    }
+    if (U == Failure) {
+      return foldAsync<Failure>(
+        (left) => throw const ResultException(
+          'Illegal use. You should check right value before calling',
+        ),
+        Future.value,
+      ) as Future<U>;
+    }
+    throw ResultException(
+      'Illegal use. You should use $Success or $Failure type',
+    );
+  }
+
+  /// Fold [Ok] and [Err] into the value of one type
+  U fold<U>(
+    U Function(Success value) valueTransformer,
+    U Function(Failure error) errorTransformer,
+  ) =>
+      _result.fold(
+        (ok) => valueTransformer(ok),
+        (err) => errorTransformer(err),
+      );
+
+  /// Fold [Ok] and [Err] **asynchronously** into the value of one type
+  Future<U> foldAsync<U>(
+    Future<U> Function(Success value) valueTransformer,
+    Future<U> Function(Failure error) errorTransformer,
+  ) =>
+      _result.foldAsync(
+        (ok) => valueTransformer(ok),
+        (err) => errorTransformer(err),
+      );
+
+  /// Swap [Ok] and [Err]
+  Result<Failure, Success> swap() => fold(
+        Err.new,
+        Ok.new,
+      );
+
+  /// Returns [res] if the [Result] is [Ok], otherwise returns
+  /// the [Err] value of this.
+  Result<U, Failure> and<U>(Result<U, Failure> res) => Result._(
+        _result.and(res._result),
+      );
+
+  /// Returns [res] if the [Result] is [Err], otherwise returns
+  /// the [Ok] value of this.
+  Result<Success, F> or<F>(Result<Success, F> res) => Result._(
+        _result.or(res._result),
+      );
+
+  /// Returns true if the result is an [Ok] or [Err] value containing
+  /// the given value/error.
+  bool contains<U>(U x) {
+    if (x is Success) {
+      return _result.contains(x);
+    } else if (x is Failure) {
+      return _result.containsErr(x);
+    } else {
+      throw ArgumentError('The value must be of type Success or Failure');
+    }
+  }
+
+  /// Returns the contained [Ok] value. Throw [ResultException] on [Err]
+  /// with its content.
+  Success expect(String msg) {
+    try {
+      return _result.expect(msg);
+    } on sealed.ResultException catch (e) {
+      throw ResultException(e.message.toString());
+    }
+  }
+
+  /// Returns the contained [Err] value. Throw [ResultException] on [Ok]
+  /// with its content.
+  Failure expectErr(String msg) {
+    try {
+      return _result.expectErr(msg);
+    } on sealed.ResultException catch (e) {
+      throw ResultException(e.message.toString());
+    }
+  }
+
+  /// Maps a [Result<Success, Failure>] to [Result<U, Failure>] by applying a
+  /// function to a contained [Ok] value, leaving an [Err] value untouched.
+  Result<U, Failure> map<U>(U Function(Success value) mapper) =>
+      Result._(_result.map(mapper));
+
+  /// Maps a [Result<Success, Failure>] to [Result<U, Failure>] by applying
+  /// an **async** function to a contained [Ok] value, leaving an [Err]
+  /// value untouched.
+  Future<Result<U, Failure>> mapAsync<U>(
+    Future<U> Function(Success value) mapper,
+  ) async {
+    final result = await _result.mapAsync(mapper);
+    return Result._(result);
+  }
+
+  /// Maps a [Result<Success, Failure>] to [Result<Success, F>] by applying a
+  /// function to a contained [Err] value, leaving an [Ok] value untouched.
+  Result<Success, F> mapErr<F>(F Function(Failure error) mapper) =>
+      Result._(_result.mapErr(mapper));
+
+  /// Maps a [Result<Success, Failure>] to [Result<U, Failure>] by applying
+  /// an **async** function to a contained [Err] value, leaving an [Ok]
+  /// value untouched.
+  Future<Result<Success, F>> mapErrAsync<F>(
+    Future<F> Function(Failure error) mapper,
+  ) async {
+    final result = await _result.mapErrAsync(mapper);
+    return Result._(result);
+  }
+
+  /// Transforms a [Result<Success, Failure>] to [Result<U, F>] by applying
+  /// functions to contained [Ok] and [Err] values.
+  Result<U, F> either<U, F>(
+    U Function(Success value) valueTransformer,
+    F Function(Failure error) errorTransformer,
+  ) =>
+      Result._(
+        _result
+            .map(
+              valueTransformer,
+            )
+            .mapErr(
+              errorTransformer,
+            ),
+      );
+
+  /// Transforms a [Result<Success, Failure>] to [Result<U, F>] by
+  /// applying **async** functions to contained [Ok] and [Err] values.
+  Future<Result<U, F>> eitherAsync<U, F>(
+    Future<U> Function(Success value) valueTransformer,
+    Future<F> Function(Failure error) errorTransformer,
+  ) =>
+      _result
+          .mapAsync(
+            valueTransformer,
+          )
+          .mapErrAsync(
+            errorTransformer,
+          )
+          .then(Result._);
+
+  /// Constructs a new [Result] from a function that might throw
+  static Result<Success, Failure>
+      tryCatch<Success, Failure, Error extends Object>(
+    Success Function() tryFn,
+    Failure Function(Error error) onError,
+  ) {
+    try {
+      return Ok(tryFn());
+    } on Error catch (e) {
+      return Err(onError(e));
+    }
+  }
+
+  /// Constructs a new [Result] from an **async** function that might throw
+  static Future<Result<Success, Failure>>
+      tryCatchAsync<Success, Failure, Error extends Object>(
+    Future<Success> Function() tryFn,
+    Failure Function(Error error) onError,
+  ) async {
+    try {
+      return Ok(await tryFn());
+    } on Error catch (e) {
+      return Err(onError(e));
+    }
+  }
+
+  /// If the condition is satify then return [value] in
+  /// [Ok] else [error] in [Err]
+  static Result<Success, Failure> conditional<Success, Failure>(
+    Success value,
+    Failure error, {
+    required bool test,
+  }) =>
+      test ? Ok(value) : Err(error);
+
+  /// If the condition is satify then return *command* [value]
+  /// in [Ok] else [error] in [Err]
+  static Result<Success, Failure> conditionalLazy<Success, Failure>(
+    Success Function() value,
+    Failure Function() error,
+    bool Function() predicate,
+  ) =>
+      predicate.call() ? Ok(value()) : Err(error());
+
+  @override
+  int get hashCode => _result.hashCode;
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) {
+      return true;
+    }
+    return other is Result<Success, Failure> && other._result == _result;
+  }
+}
+
+final class Ok<Success, Failure> extends Result<Success, Failure> {
+  Ok(this.ok) : super._(sealed.Ok(ok));
+
+  @override
+  final Success ok;
+
+  @override
+  bool get isErr => false;
+
+  @override
+  bool get isOk => true;
+
+  @override
+  Failure? get err => null;
+
+  @override
+  String toString() => switch (ok) {
+        null => 'Ok(null)',
+        Future() => 'Ok(${ok.runtimeType})',
+        _ => 'Ok($ok)',
+      };
+}
+
+final class Err<Success, Failure> extends Result<Success, Failure> {
+  Err(this.err) : super._(sealed.Err(err));
+
+  @override
+  final Failure err;
+
+  @override
+  bool get isErr => true;
+
+  @override
+  bool get isOk => false;
+
+  @override
+  Success? get ok => null;
+
+  @override
+  String toString() => switch (err) {
+        _ => 'Err($err)',
+      };
+}

packages/wyatt_type_utils/lib/src/src.dart

@@ -1,4 +1,4 @@
-// Copyright (C) 2022 WYATT GROUP
+// Copyright (C) 2024 WYATT GROUP
 // Please see the AUTHORS file for details.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -17,3 +17,4 @@
 export 'either/either_base.dart';
 export 'extensions/extensions.dart';
 export 'pair/pair.dart';
+export 'result/result.dart';

packages/wyatt_type_utils/pubspec.yaml

@@ -6,11 +6,14 @@ version: 0.0.5
 publish_to: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
 
 environment:
-  sdk: ">=2.17.0 <3.0.0"
+  sdk: "^3.0.0"
+
+dependencies:
+  sealed_result: ^3.0.0
 
 dev_dependencies:
   test: ^1.22.0
 
   wyatt_analysis:
     hosted: https://git.wyatt-studio.fr/api/packages/Wyatt-FOSS/pub
-    version: ^2.5.0
+    version: ^2.6.1

packages/wyatt_type_utils/test/result_test.dart

@@ -21,85 +21,83 @@ void main() {
   group('Result<T,E>', () {
     test('`isOk` returns true on Ok value', () {
       expect(
-        const Ok<void, void>(null).isOk,
+        Ok<void, void>(null).isOk,
         true,
       );
       expect(
-        const Err<void, void>(null).isOk,
+        Err<void, void>(null).isOk,
         false,
       );
     });
 
     test('`isErr` returns true on Err value', () {
       expect(
-        const Ok<void, void>(null).isErr,
+        Ok<void, void>(null).isErr,
         false,
       );
       expect(
-        const Err<void, void>(null).isErr,
+        Err<void, void>(null).isErr,
         true,
       );
     });
 
     test('`ok` returns value on Ok value', () {
-      const Result<int, String> x = Ok(2);
+      final Result<int, String> x = Ok(2);
       expect(x.ok, 2);
       expect(x.err, null);
     });
 
     test('`err` returns error on Err value', () {
-      const Result<int, String> x = Err('error');
+      final Result<int, String> x = Err('error');
       expect(x.ok, null);
       expect(x.err, 'error');
     });
 
     test('unwrap() returns value on Ok value', () {
-      const Result<int, String> x = Ok(2);
+      final Result<int, String> x = Ok(2);
       expect(x.unwrap<int>(), 2);
       expect(() => x.unwrap<String>(), throwsA(isException));
     });
 
     test('unwrap() returns error on Err value', () {
-      const Result<int, String> x = Err('error');
+      final Result<int, String> x = Err('error');
       expect(x.unwrap<String>(), 'error');
       expect(() => x.unwrap<int>(), throwsA(isException));
     });
 
     test('unwrapAsync() returns value on Ok value', () async {
-      const Result<int, String> x = Ok(2);
+      final Result<int, String> x = Ok(2);
       expect(await x.unwrapAsync<int>(), 2);
       expect(() async => x.unwrapAsync<String>(), throwsA(isException));
     });
 
     test('unwrapAsync() returns error on Err value', () async {
-      const Result<int, String> x = Err('error');
+      final Result<int, String> x = Err('error');
       expect(await x.unwrapAsync<String>(), 'error');
       expect(() async => x.unwrapAsync<int>(), throwsA(isException));
     });
 
     test('fold() returns right value', () {
       expect(
-        const Ok<String, String>('')
-            .fold<bool>((left) => true, (right) => false),
+        Ok<String, String>('').fold<bool>((left) => true, (right) => false),
         true,
       );
       expect(
-        const Err<String, String>('')
-            .fold<bool>((left) => true, (right) => false),
+        Err<String, String>('').fold<bool>((left) => true, (right) => false),
         false,
       );
     });
 
     test('foldAsync() returns right value', () async {
       expect(
-        await const Ok<String, String>('').foldAsync<bool>(
+        await Ok<String, String>('').foldAsync<bool>(
           (left) => Future.value(true),
           (right) => Future.value(false),
         ),
         true,
       );
       expect(
-        await const Err<String, String>('').foldAsync<bool>(
+        await Err<String, String>('').foldAsync<bool>(
           (left) => Future.value(true),
           (right) => Future.value(false),
         ),
@@ -108,7 +106,7 @@ void main() {
     });
 
     test('swap() swaps values', () {
-      const Result<int, int> x = Ok(10);
+      final Result<int, int> x = Ok(10);
       expect(x.isOk, true);
       expect(x.isErr, false);
       expect(x.ok, 10);
@@ -122,24 +120,24 @@ void main() {
       'and() returns res if the result is `Ok`, otherwise '
       'returns the `Err` value of this.',
       () {
-        const Result<int, String> x1 = Ok(2);
-        const Result<int, String> y1 = Err('late error');
+        final Result<int, String> x1 = Ok(2);
+        final Result<int, String> y1 = Err('late error');
         expect(x1.and(y1), y1);
 
-        const Result<String, String> x2 = Err('early error');
-        const Result<String, String> y2 = Ok('foo');
+        final Result<String, String> x2 = Err('early error');
+        final Result<String, String> y2 = Ok('foo');
         expect(x2.and(y2), x2);
 
-        const Result<void, String> x3 = Err('not a 2');
-        const Result<void, String> y3 = Err('late error');
+        final Result<void, String> x3 = Err('not a 2');
+        final Result<void, String> y3 = Err('late error');
         expect(x3.and(y3), x3);
 
-        const Result<dynamic, void> x4 = Ok(2);
-        const Result<dynamic, void> y4 = Ok('different result type');
+        final Result<dynamic, void> x4 = Ok(2);
+        final Result<dynamic, void> y4 = Ok('different result type');
         expect(x4.and(y4), y4);
 
-        const Result<int, void> x5 = Ok(2);
-        const Result<int, void> y5 = Ok(5);
+        final Result<int, void> x5 = Ok(2);
+        final Result<int, void> y5 = Ok(5);
         expect(x5.and(y5), y5);
       },
     );
@@ -148,24 +146,24 @@ void main() {
       'or() returns res if the result is `Err`, otherwise '
       'returns the `Ok` value of this.',
       () {
-        const Result<int, String> x1 = Ok(2);
-        const Result<int, String> y1 = Err('late error');
+        final Result<int, String> x1 = Ok(2);
+        final Result<int, String> y1 = Err('late error');
         expect(x1.or(y1), x1);
 
-        const Result<String, String> x2 = Err('early error');
-        const Result<String, String> y2 = Ok('foo');
+        final Result<String, String> x2 = Err('early error');
+        final Result<String, String> y2 = Ok('foo');
         expect(x2.or(y2), y2);
 
-        const Result<void, String> x3 = Err('not a 2');
-        const Result<void, String> y3 = Err('late error');
+        final Result<void, String> x3 = Err('not a 2');
+        final Result<void, String> y3 = Err('late error');
         expect(x3.or(y3), y3);
 
-        const Result<dynamic, void> x4 = Ok(2);
-        const Result<dynamic, void> y4 = Ok('different result type');
+        final Result<dynamic, void> x4 = Ok(2);
+        final Result<dynamic, void> y4 = Ok('different result type');
         expect(x4.or(y4), x4);
 
-        const Result<int, void> x5 = Ok(2);
-        const Result<int, void> y5 = Ok(5);
+        final Result<int, void> x5 = Ok(2);
+        final Result<int, void> y5 = Ok(5);
         expect(x5.or(y5), x5);
       },
     );
@@ -174,10 +172,10 @@ void main() {
       'contains() returns true if the result is an Ok value '
       'containing the given value.',
       () {
-        const Result<int, void> x1 = Ok(2);
+        final Result<int, void> x1 = Ok(2);
         expect(x1.contains(2), true);
         expect(x1.contains(3), false);
-        const Result<void, String> x2 = Err('Some error message');
+        final Result<void, String> x2 = Err('Some error message');
         expect(x2.contains(2), false);
       },
     );
@@ -186,10 +184,10 @@ void main() {
       'expect() return value if the result is an Ok value '
       'else throw Exception',
       () {
-        const Result<int, String> x1 = Ok(2);
+        final Result<int, String> x1 = Ok(2);
         expect(x1.expect('Testing expect'), 2);
 
-        const Result<int, String> x2 = Err('emergency failure');
+        final Result<int, String> x2 = Err('emergency failure');
         expect(
           () => x2.expect('Testing expect'),
           throwsA(
@@ -205,10 +203,10 @@ void main() {
       'expectErr() return value if the result is an Err value '
       'else throw Exception',
       () {
-        const Result<String, int> x1 = Err(2);
+        final Result<String, int> x1 = Err(2);
         expect(x1.expectErr('Testing expect err'), 2);
 
-        const Result<String, int> x2 = Ok('success value');
+        final Result<String, int> x2 = Ok('success value');
         expect(
           () => x2.expectErr('Testing expect err'),
           throwsA(
@@ -223,12 +221,12 @@ void main() {
     test(
       'map() transforms Ok value.',
       () {
-        const Result<bool, void> x1 = Ok(true);
+        final Result<bool, void> x1 = Ok(true);
 
         expect(x1.ok, true);
         expect(x1.map((value) => false).ok, false);
 
-        const Result<bool, String> x2 = Err('oops');
+        final Result<bool, String> x2 = Err('oops');
 
         expect(x2.map((value) => false).isErr, true);
       },
@@ -237,11 +235,11 @@ void main() {
     test(
       'mapErr() transforms Err value.',
       () {
-        const Result<bool, String> x1 = Ok(true);
+        final Result<bool, String> x1 = Ok(true);
 
         expect(x1.mapErr((value) => false).isOk, true);
 
-        const Result<bool, String> x2 = Err('oops');
+        final Result<bool, String> x2 = Err('oops');
 
         expect(x2.err, 'oops');
         expect(x2.mapErr((error) => 'failure').err, 'failure');
@@ -251,12 +249,12 @@ void main() {
     test(
       'mapAsync() transforms Ok value.',
       () async {
-        const Result<bool, void> x1 = Ok(true);
+        final Result<bool, void> x1 = Ok(true);
 
         expect(x1.ok, true);
         expect((await x1.mapAsync((value) => Future.value(false))).ok, false);
 
-        const Result<bool, String> x2 = Err('oops');
+        final Result<bool, String> x2 = Err('oops');
 
         expect((await x2.mapAsync((value) => Future.value(false))).isErr, true);
       },
@@ -265,14 +263,14 @@ void main() {
     test(
       'mapErrAsync() transforms Err value.',
       () async {
-        const Result<bool, String> x1 = Ok(true);
+        final Result<bool, String> x1 = Ok(true);
 
         expect(
           (await x1.mapErrAsync((value) => Future.value(false))).isOk,
           true,
         );
 
-        const Result<bool, String> x2 = Err('oops');
+        final Result<bool, String> x2 = Err('oops');
 
         expect(x2.err, 'oops');
         expect(
@@ -285,14 +283,14 @@ void main() {
     test(
       'either() transforms values.',
       () {
-        const Result<bool, bool> x1 = Ok(true);
+        final Result<bool, bool> x1 = Ok(true);
         final Result<int, String> y1 =
             x1.either<int, String>((value) => 1, (error) => 'error');
 
         expect(y1.isOk, true);
         expect(y1.ok, 1);
 
-        const Result<bool, bool> x2 = Err(true);
+        final Result<bool, bool> x2 = Err(true);
         final Result<int, String> y2 =
             x2.either<int, String>((value) => 1, (error) => 'error');
 
@@ -304,7 +302,7 @@ void main() {
     test(
       'eitherAsync() transforms values.',
       () async {
-        const Result<bool, bool> x1 = Ok(true);
+        final Result<bool, bool> x1 = Ok(true);
         final Result<int, String> y1 = await x1.eitherAsync<int, String>(
           (value) => Future.value(1),
           (error) => Future.value('error'),
@@ -313,7 +311,7 @@ void main() {
         expect(y1.isOk, true);
         expect(y1.ok, 1);
 
-        const Result<bool, bool> x2 = Err(true);
+        final Result<bool, bool> x2 = Err(true);
         final Result<int, String> y2 = await x2.eitherAsync<int, String>(
           (value) => Future.value(1),
           (error) => Future.value('error'),
@@ -370,9 +368,9 @@ void main() {
       'conditional() returns Result on true test',
       () {
         final Result<int, String> x1 = Result.conditional<int, String>(
-          false,
           2,
           'error',
+          test: false,
         );
         expect(
           x1.isErr,
@@ -382,9 +380,9 @@ void main() {
         expect(x1.err, 'error');
 
         final Result<int, String> x2 = Result.conditional<int, String>(
-          true,
           2,
           'error',
+          test: true,
         );
         expect(
           x2.isOk,
@@ -399,9 +397,9 @@ void main() {
       'conditionalLazy() returns Result on true test',
       () {
         final Result<int, String> x1 = Result.conditionalLazy<int, String>(
-          false,
           () => 2,
           () => 'error',
+          () => false,
         );
         expect(
           x1.isErr,
@@ -411,9 +409,9 @@ void main() {
         expect(x1.err, 'error');
 
         final Result<int, String> x2 = Result.conditionalLazy<int, String>(
-          true,
           () => 2,
           () => 'error',
+          () => true,
         );
         expect(
           x2.isOk,