kasy-cli 1.2.1

package/lib/scaffold/backends/api/patch/lib/features/authentication/repositories/authentication_repository.dart

@@ -0,0 +1,406 @@
+import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/core/data/api/user_api.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+import 'package:kasy_kit/core/security/secured_storage.dart';
+import 'package:kasy_kit/features/authentication/api/authentication_api.dart';
+import 'package:kasy_kit/features/authentication/api/authentication_api_interface.dart';
+import 'package:kasy_kit/features/authentication/repositories/exceptions/authentication_exceptions.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+
+final authRepositoryProvider = Provider<AuthenticationRepository>(
+  (Ref ref) => HttpAuthenticationRepository(
+    logger: Logger(),
+    authenticationApi: ref.read(authenticationApiProvider),
+    storage: ref.read(authSecuredStorageProvider),
+    userApi: ref.read(userApiProvider),
+    httpClient: ref.read(httpClientProvider),
+  ),
+);
+
+abstract class AuthenticationRepository {
+  /// Signup a user anonymously
+  /// The user is signed in with an ID
+  /// but we don't have any information about him (email, name, ...)
+  /// This allows him to have a temporary account that he can link to an email or social login later
+  Future<void> signupAnonymously();
+
+  /// Signup a user with [email] and [password]
+  /// The user is signed in automatically
+  /// We SHOULD NOT store the password in the database
+  /// We stores the token in the secured storage
+  /// throws [SignupException] if an error occurs
+  Future<void> signup(String email, String password);
+
+  /// Signin a user with [email] and [password]
+  /// The user is signed in automatically
+  /// We SHOULD NOT store the password in the database
+  /// We stores the token in the secured storage
+  /// throws [SigninException] if an error occurs
+  Future<void> signin(String email, String password);
+
+  /// Get the current user or null if not connected
+  Future<Credentials?> get();
+
+  /// Logout the current user
+  /// We clear the token from the secured storage
+  Future<void> logout();
+
+  /// Signin with Google account
+  Future<void> signinWithGoogle();
+
+  /// Signin with Google Play Games account on Android
+  Future<void> signinWithGooglePlayGames();
+
+  /// Signin with Facebook account
+  Future<void> signinWithFacebook();
+
+  /// Signin with Apple account
+  Future<void> signinWithApple();
+
+  /// Recover password
+  /// (send an email to the user with a link to reset the password)
+  Future<void> recoverPassword(String email);
+
+  /// Request a verification code to be sent to the provided phone number
+  /// Returns a verification id that will be used to verify the code
+  Future<String> signinWithPhone(String phoneNumber);
+
+  /// Verify the phone number with the code sent to the user
+  /// The user is signed in automatically if the verification is successful
+  /// We store the token in the secured storage
+  /// throws [PhoneAuthException] if an error occurs
+  Future<void> verifyPhoneAuth(String verificationId, String otp);
+
+  /// Update the phone number of the current user
+  /// The user is signed in automatically if the verification is successful
+  /// We store the token in the secured storage
+  /// throws [PhoneAuthException] if an error occurs
+  Future<String> updateAuthPhone(String phoneNumber);
+
+  /// Confirm the link of a phone number to the current user
+  /// The user is signed in automatically if the verification is successful
+  /// We store the token in the secured storage
+  /// throws [PhoneAuthException] if an error occurs
+  Future<void> confirmLinkPhoneAuth(String verificationId, String otp);
+
+  /// Links an anonymous/guest session to a permanent Google account.
+  Future<void> signupFromAnonymousWithGoogle();
+
+  /// Links an anonymous/guest session to a permanent Apple account.
+  Future<void> signupFromAnonymousWithApple();
+
+  /// Links an anonymous/guest session to a permanent Facebook account.
+  Future<void> signupFromAnonymousWithFacebook();
+
+  /// Returns the email of the current user, or null.
+  Future<String?> getCurrentUserEmail();
+
+  /// Returns the display name of the current user, or null.
+  Future<String?> getCurrentUserDisplayName();
+}
+
+/// this is an example on how to create an authentication repository using firebase
+class HttpAuthenticationRepository implements AuthenticationRepository {
+  final Logger _logger;
+  final AuthenticationApi _authenticationApi;
+  final AuthSecuredStorage _storage;
+  // ignore: unused_field
+  final UserApi _userApi;
+  final HttpClient _httpClient;
+
+  HttpAuthenticationRepository({
+    required Logger logger,
+    required AuthenticationApi authenticationApi,
+    required AuthSecuredStorage storage,
+    required UserApi userApi,
+    required HttpClient httpClient,
+  })  : _logger = logger,
+        _httpClient = httpClient,
+        _userApi = userApi,
+        _authenticationApi = authenticationApi,
+        _storage = storage;
+
+  @override
+  Future<void> signupAnonymously() async {
+    try {
+      _logger.d('Signup anonymously up');
+      final credentials = await _authenticationApi.signinAnonymously();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on ApiError catch (e) {
+      throw SignupException.fromApiError(e);
+    } catch (e) {
+      throw SignupException(
+        code: 0,
+        message: 'Unknown error $e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signup(String email, String password) async {
+    try {
+      _logger.d('Signing up with $email');
+      final credentials = await _authenticationApi.signup(email, password);
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on ApiError catch (e) {
+      throw SignupException.fromApiError(e);
+    } catch (e) {
+      throw SignupException(
+        code: 0,
+        message: 'Unknown error $e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signin(String email, String password) async {
+    try {
+      _logger.d('Signing in with $email');
+      final credentials = await _authenticationApi.signin(email, password);
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> recoverPassword(String email) async {
+    try {
+      await _authenticationApi.recoverPassword(email);
+    } on ApiError catch (e) {
+      throw RecoverPasswordException.fromApiError(e);
+    } catch (e) {
+      throw RecoverPasswordException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signinWithGoogle() async {
+    try {
+      _logger.d('Signing in with Google');
+      final credentials = await _authenticationApi.signinWithGoogle();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signinWithGooglePlayGames() async {
+    try {
+      _logger.d('Signing in with Google play games');
+      final credentials = await _authenticationApi.signinWithGooglePlay();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signinWithApple() async {
+    try {
+      _logger.d('Signing in with Apple');
+      final credentials = await _authenticationApi.signinWithApple();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signinWithFacebook() async {
+    try {
+      _logger.d('Signing in with Facebook');
+      final credentials = await _authenticationApi.signinWithFacebook();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(
+        code: 0,
+        message: '$e',
+      );
+    }
+  }
+
+  @override
+  Future<void> logout() async {
+    _logger.d('Logging out');
+    _httpClient.authToken = null;
+    await _authenticationApi.signout();
+    await _storage.clear();
+  }
+
+  @override
+  Future<Credentials?> get() async {
+    final credentials = await _storage.read();
+    if (credentials != null) {
+      _httpClient.authToken = credentials.token;
+    }
+    return credentials;
+  }
+
+  @override
+  Future<String> signinWithPhone(String phoneNumber) {
+    try {
+      _logger.d('Requesting phone authentication for $phoneNumber');
+      return _authenticationApi.signinWithPhone(phoneNumber);
+    } on ApiError catch (e) {
+      throw PhoneAuthException.fromApiError(e);
+    } catch (e) {
+      throw PhoneAuthException(
+        code: 0,
+        message: 'Unknown error: $e',
+      );
+    }
+  }
+
+  @override
+  Future<void> verifyPhoneAuth(String verificationId, String otp) async {
+    try {
+      _logger.d('Verifying phone code');
+      final credentials = await _authenticationApi.verifyPhoneAuth(
+        verificationId,
+        otp,
+      );
+
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on ApiError catch (e) {
+      throw PhoneAuthException.fromApiError(e);
+    } catch (e) {
+      throw PhoneAuthException(
+        code: 0,
+        message: 'Unknown error: $e',
+      );
+    }
+  }
+
+  @override
+  Future<String> updateAuthPhone(String phoneNumber) {
+    try {
+      _logger.d('Updating phone number to $phoneNumber');
+      return _authenticationApi.updateAuthPhone(phoneNumber);
+    } on PhoneAlreadyLinkedException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw PhoneAuthException.fromApiError(e);
+    } catch (e) {
+      throw PhoneAuthException(
+        code: 0,
+        message: 'Unknown error: $e',
+      );
+    }
+  }
+
+  @override
+  Future<void> confirmLinkPhoneAuth(String verificationId, String otp) async {
+    try {
+      _logger.d('Confirming link phone auth');
+      await _authenticationApi.confirmLinkPhoneAuth(verificationId, otp);
+    } on PhoneAlreadyLinkedException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw PhoneAuthException.fromApiError(e);
+    } catch (e) {
+      throw PhoneAuthException(
+        code: 0,
+        message: 'Unknown error: $e',
+      );
+    }
+  }
+
+  @override
+  Future<void> signupFromAnonymousWithGoogle() async {
+    try {
+      _logger.d('Linking anonymous account with Google');
+      final credentials = await _authenticationApi.signupFromAnonymousWithGoogle();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(code: 0, message: '$e');
+    }
+  }
+
+  @override
+  Future<void> signupFromAnonymousWithApple() async {
+    try {
+      _logger.d('Linking anonymous account with Apple');
+      final credentials = await _authenticationApi.signupFromAnonymousWithApple();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(code: 0, message: '$e');
+    }
+  }
+
+  @override
+  Future<void> signupFromAnonymousWithFacebook() async {
+    try {
+      _logger.d('Linking anonymous account with Facebook');
+      final credentials = await _authenticationApi.signupFromAnonymousWithFacebook();
+      await _storage.write(value: credentials);
+      _httpClient.authToken = credentials.token;
+    } on UserCancelledSignInException {
+      rethrow;
+    } on ApiError catch (e) {
+      throw SigninException.fromApiError(e);
+    } catch (e) {
+      throw SigninException(code: 0, message: '$e');
+    }
+  }
+
+  @override
+  Future<String?> getCurrentUserEmail() => _authenticationApi.getCurrentUserEmail();
+
+  @override
+  Future<String?> getCurrentUserDisplayName() => _authenticationApi.getCurrentUserDisplayName();
+}

package/lib/scaffold/backends/api/patch/lib/features/camera/xfile_extension.dart

@@ -0,0 +1,6 @@
+import 'package:open_filex/open_filex.dart';
+import 'package:cross_file/cross_file.dart';
+
+extension XfileOpen on XFile {
+  Future<void> open() => OpenFilex.open(path);
+}

package/lib/scaffold/backends/api/patch/lib/features/feedbacks/api/entities/feature_request_entity.dart

@@ -0,0 +1,24 @@
+// ignore_for_file: invalid_annotation_target
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'feature_request_entity.freezed.dart';
+part 'feature_request_entity.g.dart';
+
+@freezed
+sealed class FeatureRequestEntity with _$FeatureRequestEntity {
+  const factory FeatureRequestEntity({
+    @JsonKey() String? id,
+    @JsonKey(name: 'creation_date') required DateTime creationDate,
+    @JsonKey(name: 'last_update_date') required DateTime lastUpdateDate,
+    required Map<String, String> title,
+    required Map<String, String> description,
+    required int votes,
+    required bool active,
+  }) = FeatureRequestEntityData;
+
+  const FeatureRequestEntity._();
+
+  factory FeatureRequestEntity.fromJson(Map<String, dynamic> json) =>
+      _$FeatureRequestEntityFromJson(json);
+}

package/lib/scaffold/backends/api/patch/lib/features/feedbacks/api/entities/feature_vote_entity.dart

@@ -0,0 +1,21 @@
+// ignore_for_file: invalid_annotation_target
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'feature_vote_entity.freezed.dart';
+part 'feature_vote_entity.g.dart';
+
+@freezed
+abstract class UserFeatureVoteEntity with _$UserFeatureVoteEntity {
+  const factory UserFeatureVoteEntity({
+    @JsonKey() String? id,
+    @JsonKey(name: 'creation_date') required DateTime creationDate,
+    @JsonKey(name: 'user_id') required String userId,
+    @JsonKey(name: 'feature_id') required String featureId,
+  }) = UserFeatureVoteEntityData;
+
+  const UserFeatureVoteEntity._();
+
+  factory UserFeatureVoteEntity.fromJson(Map<String, dynamic> json) =>
+      _$UserFeatureVoteEntityFromJson(json);
+}

package/lib/scaffold/backends/api/patch/lib/features/feedbacks/api/feature_request_api.dart

@@ -0,0 +1,52 @@
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/feedbacks/api/entities/feature_request_entity.dart';
+
+final featureRequestApiProvider = Provider<FeatureRequestApi>(
+  (ref) => FeatureRequestApi(
+    client: ref.read(httpClientProvider),
+  ),
+);
+
+/// REST endpoints expected:
+///   GET  /feature-requests              → List<FeatureRequestEntity> (only active)
+///   POST /feature-requests              body: {title, description} → 201 Created
+///     Server creates with active: false and stores title/description in all locales.
+class FeatureRequestApi {
+  final HttpClient _client;
+
+  FeatureRequestApi({required HttpClient client}) : _client = client;
+
+  Future<List<FeatureRequestEntity>> getAllActive() async {
+    try {
+      final response = await _client.get('/feature-requests');
+      final list = response.data as List<dynamic>;
+      return list
+          .map((e) => FeatureRequestEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+
+  Future<String> create({
+    required String title,
+    required String description,
+  }) async {
+    try {
+      final response = await _client.post(
+        '/feature-requests',
+        data: {'title': title, 'description': description},
+      );
+      return (response.data as Map<String, dynamic>)['id'] as String;
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/feedbacks/api/feature_vote_api.dart

@@ -0,0 +1,60 @@
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/data/api/base_api_exceptions.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/feedbacks/api/entities/feature_vote_entity.dart';
+
+final featureVoteApiProvider = Provider<FeatureVoteApi>(
+  (ref) => FeatureVoteApi(
+    client: ref.read(httpClientProvider),
+  ),
+);
+
+/// REST endpoints expected:
+///   GET    /feature-votes          → List<UserFeatureVoteEntity> (filtered by authenticated user)
+///   POST   /feature-votes          → UserFeatureVoteEntity  body: {feature_id}
+///   DELETE /feature-votes/:id      → 204 No Content
+class FeatureVoteApi {
+  final HttpClient _client;
+
+  FeatureVoteApi({required HttpClient client}) : _client = client;
+
+  Future<List<UserFeatureVoteEntity>> getUserVotes(String userId) async {
+    try {
+      final response = await _client.get('/feature-votes');
+      final list = response.data as List<dynamic>;
+      return list
+          .map((e) => UserFeatureVoteEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+
+  Future<UserFeatureVoteEntity> create(String userId, String featureId) async {
+    try {
+      final response = await _client.post(
+        '/feature-votes',
+        data: {'feature_id': featureId},
+      );
+      return UserFeatureVoteEntity.fromJson(
+          response.data as Map<String, dynamic>);
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+
+  Future<void> delete(String featureId, String voteId) async {
+    try {
+      await _client.delete('/feature-votes/$voteId');
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, s) {
+      throw ApiError(code: 0, message: '$e: $s');
+    }
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/llm_chat/api/llm_chat_api.dart

@@ -0,0 +1,58 @@
+import 'package:dio/dio.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:logger/logger.dart';
+import 'package:kasy_kit/core/data/api/http_client.dart';
+import 'package:kasy_kit/features/llm_chat/api/llm_chat_message_entity.dart';
+
+final llmChatApiProvider = Provider<LlmChatApi>(
+  (ref) => LlmChatApi(client: ref.read(httpClientProvider)),
+);
+
+/// REST endpoints expected on your backend:
+///   GET    /llm-messages            → List<LlmChatMessageEntity> (current user)
+///   POST   /llm-messages            → saves one message
+///   DELETE /llm-messages            → clears all messages (current user)
+///
+/// The server identifies the user via the Authorization: Bearer token
+/// injected automatically by HttpClient.
+class LlmChatApi {
+  final HttpClient _client;
+  final Logger _logger = Logger();
+
+  LlmChatApi({required HttpClient client}) : _client = client;
+
+  /// Returns all messages for the authenticated user, ordered oldest first.
+  Future<List<LlmChatMessageEntity>> loadMessages(String userId) async {
+    try {
+      final response = await _client.get('/llm-messages');
+      final list = response.data as List<dynamic>;
+      return list
+          .map((e) => LlmChatMessageEntity.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } on DioException catch (e) {
+      _logger.e('Failed to load LLM messages: $e');
+      return [];
+    }
+  }
+
+  /// Persists a single message via POST.
+  Future<void> saveMessage(
+    String userId,
+    LlmChatMessageEntity message,
+  ) async {
+    try {
+      await _client.post('/llm-messages', data: message.toJson());
+    } catch (e) {
+      _logger.e('Failed to persist LLM message: $e');
+    }
+  }
+
+  /// Deletes all stored messages for the authenticated user.
+  Future<void> clearHistory(String userId) async {
+    try {
+      await _client.delete('/llm-messages');
+    } catch (e) {
+      _logger.e('Failed to clear LLM history: $e');
+    }
+  }
+}

package/lib/scaffold/backends/api/patch/lib/features/llm_chat/api/llm_chat_message_entity.dart

@@ -0,0 +1,29 @@
+/// REST API response mapping for a single LLM chat message.
+class LlmChatMessageEntity {
+  final String? id;
+  final String role; // 'user' or 'assistant'
+  final String content;
+  final DateTime createdAt;
+
+  const LlmChatMessageEntity({
+    this.id,
+    required this.role,
+    required this.content,
+    required this.createdAt,
+  });
+
+  factory LlmChatMessageEntity.fromJson(Map<String, dynamic> json) {
+    return LlmChatMessageEntity(
+      id: json['id'] as String?,
+      role: json['role'] as String,
+      content: json['content'] as String,
+      createdAt: DateTime.parse(json['created_at'] as String),
+    );
+  }
+
+  Map<String, dynamic> toJson() => {
+        'role': role,
+        'content': content,
+        'created_at': createdAt.toUtc().toIso8601String(),
+      };
+}