coregen-cli 3.1.6__py3-none-any.whl

generators/static/templates/auth/infrastructure/auth_facade_template.jinja

@@ -0,0 +1,288 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import 'package:[[project_name]]/storage/storage_repository.dart';
+import 'package:[[project_name]]/domain/auth/model/value_objects.dart';
+import 'package:[[project_name]]/domain/auth/model/user.dart' as auth_user;
+import 'package:[[project_name]]/domain/auth/model/auth_failure.dart';
+import 'package:[[project_name]]/domain/auth/model/i_auth_facade.dart';
+
+/// NOTE: This class is currently a skeleton implementation. Uncomment and implement
+/// the necessary parts to enable authentication functionality.
+///
+/// This facade supports multiple authentication providers (Firebase, Google, Apple, etc.).
+/// Implement the specific authentication logic for your chosen provider(s).
+///
+/// To avoid circular dependency with IUserProfileRepository (UserProfileRepository
+/// depends on IAuthFacade), AuthFacade does NOT inject IUserProfileRepository.
+/// When implementing getSignedInUser/sign-in flows that need to sync UserProfile,
+/// resolve IUserProfileRepository lazily (e.g. via GetIt) only when needed.
+
+@lazySingleton
+class AuthFacade implements IAuthFacade {
+  // final FirebaseAuth _firebaseAuth; // Uncomment the following line to use Firebase Authentication
+  // final FirebaseUserMapper _firebaseUserMapper; // Uncomment the following line to use Firebase Authentication
+  final StorageRepository _storageRepository;
+
+  AuthFacade(
+    // this._firebaseAuth, // Uncomment the following line to use Firebase Authentication
+    // this._firebaseUserMapper, // Uncomment the following line to use Firebase Authentication
+    this._storageRepository,
+  );
+
+  @override
+  Future<Option<auth_user.User>> getSignedInUser() async {
+    // Step 1: Get auth user from authentication provider
+    // Uncomment the following lines to use Firebase Authentication
+    // final firebaseUser = _firebaseAuth.currentUser;
+    // if (firebaseUser == null) {
+    //   return none();
+    // }
+    // final authUser = _firebaseUserMapper.toDomain(firebaseUser);
+    // if (authUser == null) {
+    //   return none();
+    // }
+
+    // Stub: For now, return none() until authentication provider is implemented
+    // TODO: Replace with actual authentication provider user retrieval
+    // final authUser = ...;
+
+    // Step 2: Get or create UserProfile using authId
+    // The UserProfile is synced with the authentication User
+    // Both use the same ID (authId) for correlation
+    // try {
+    //   final authId = authUser.id.getOrCrash();
+    //   final userProfileResult = await _userProfileRepository.getByAuthId(authId);
+    //   
+    //   final UserProfile userProfile = userProfileResult.fold(
+    //     (failure) {
+    //       // UserProfile doesn't exist, create it from auth User
+    //       final newUserProfile = authUser.toUserProfile();
+    //       return newUserProfile;
+    //     },
+    //     (existingProfile) {
+    //       // UserProfile exists, update it with latest auth data if needed
+    //       // Check if name or email changed
+    //       if (existingProfile.name.getOrCrash() != authUser.name.getOrCrash() ||
+    //           existingProfile.emailAddress.getOrCrash() != authUser.emailAddress.getOrCrash()) {
+    //         final updatedProfile = authUser.toUserProfileWithTimestamps(
+    //           createdAt: existingProfile.createdAt,
+    //           updatedAt: DateTime.now(),
+    //           avatarUrl: existingProfile.avatarUrl,
+    //         );
+    //         return updatedProfile;
+    //       }
+    //       return existingProfile;
+    //     },
+    //   );
+    //
+    //   // Save/update UserProfile if it was created or updated
+    //   if (userProfileResult.isLeft()) {
+    //     await _userProfileRepository.createOrUpdate(userProfile);
+    //   } else {
+    //     // Check if update is needed
+    //     final needsUpdate = userProfile.name.getOrCrash() != authUser.name.getOrCrash() ||
+    //                         userProfile.emailAddress.getOrCrash() != authUser.emailAddress.getOrCrash();
+    //     if (needsUpdate) {
+    //       await _userProfileRepository.createOrUpdate(userProfile);
+    //     }
+    //   }
+    //
+    //   // Step 3: Return UserProfile mapped to User (for AuthBloc compatibility)
+    //   return optionOf(userProfile.toUser());
+    // } catch (e) {
+    //   // If UserProfile sync fails, fall back to auth User
+    //   return optionOf(authUser);
+    // }
+
+    return none();
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  }) async {
+    final String emailAddressStr = emailAddress.value.getOrElse(() => throw 'INVALID EMAIL');
+    final String passwordStr = password.value.getOrElse(() => throw 'INVALID PASSWORD');
+
+    // Uncomment the following code to implement Email/Password Registration with Firebase Authentication
+
+    // try {
+    //   final userCredential = await _firebaseAuth.createUserWithEmailAndPassword(
+    //     email: emailAddressStr,
+    //     password: passwordStr,
+    //   );
+
+    //   // Uncomment to save the token if needed
+
+    //   // // User registered and logged
+    //   // final user = userCredential.user;
+
+    //   // // Get ID token (JWT)
+    //   // final idToken = await user?.getIdToken();
+
+    //   // if (idToken != null) {
+    //   //   await _storageRepository.saveToken(idToken);
+    //   // }
+
+    //   // Create UserProfile after successful registration
+    //   // The UserProfile is automatically synced with the authentication User
+    //   // Both use the same ID (authId) for correlation
+    //   // if (user != null) {
+    //   //   final authUser = _firebaseUserMapper.toDomain(user);
+    //   //   if (authUser != null) {
+    //   //     final userProfile = authUser.toUserProfile();
+    //   //     await _userProfileRepository.createOrUpdate(userProfile);
+    //   //   }
+    //   // }
+
+    //   return right(unit);
+    // } on PlatformException catch (e) {
+    //   if (e.code == __STRING_12__) {
+    //     return left(const AuthFailure.emailAlreadyInUse());
+    //   } else {
+    //     return left(const AuthFailure.serverError());
+    //   }
+    // }
+
+    return right(unit);
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  }) async {
+    final String emailAddressStr = emailAddress.value.getOrElse(() => throw 'INVALID EMAIL');
+    final String passwordStr = password.value.getOrElse(() => throw 'INVALID PASSWORD');
+
+    // Uncomment the following code to implement Email/Password Sign-In with Firebase Authentication
+
+    // try {
+    //   final userCredential = await _firebaseAuth.signInWithEmailAndPassword(
+    //     email: emailAddressStr,
+    //     password: passwordStr,
+    //   );
+
+    //   // Uncomment to save the token if needed
+
+    //   // // User logged
+    //   // final user = userCredential.user;
+
+    //   // // Get ID token (JWT)
+    //   // final idToken = await user?.getIdToken();
+
+    //   // if (idToken != null) {
+    //   //   await _storageRepository.saveToken(idToken);
+    //   // }
+
+    //   // Sync UserProfile after successful sign-in
+    //   // The UserProfile is automatically synced with the authentication User
+    //   // Both use the same ID (authId) for correlation
+    //   // if (user != null) {
+    //   //   final authUser = _firebaseUserMapper.toDomain(user);
+    //   //   if (authUser != null) {
+    //   //     final authId = authUser.id.getOrCrash();
+    //   //     final userProfileResult = await _userProfileRepository.getByAuthId(authId);
+    //   //     
+    //   //     final UserProfile userProfile = userProfileResult.fold(
+    //   //       (failure) {
+    //   //         // UserProfile doesn't exist, create it from auth User
+    //   //         return authUser.toUserProfile();
+    //   //       },
+    //   //       (existingProfile) {
+    //   //         // UserProfile exists, update it with latest auth data if needed
+    //   //         if (existingProfile.name.getOrCrash() != authUser.name.getOrCrash() ||
+    //   //             existingProfile.emailAddress.getOrCrash() != authUser.emailAddress.getOrCrash()) {
+    //   //           return authUser.toUserProfileWithTimestamps(
+    //   //             createdAt: existingProfile.createdAt,
+    //   //             updatedAt: DateTime.now(),
+    //   //             avatarUrl: existingProfile.avatarUrl,
+    //   //           );
+    //   //         }
+    //   //         return existingProfile;
+    //   //       },
+    //   //     );
+    //   //
+    //   //     // Save/update UserProfile
+    //   //     await _userProfileRepository.createOrUpdate(userProfile);
+    //   //   }
+    //   // }
+
+    //   return right(unit);
+    // } on PlatformException catch (e) {
+    //   if (e.code == __STRING_15__ || e.code == __STRING_16__) {
+    //     return left(const AuthFailure.invalidEmailAndPasswordCombination());
+    //   }
+    //   return left(const AuthFailure.serverError());
+    // }
+
+    return right(unit);
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithGoogle() async {
+    // TODO: Implement Google Sign-In
+    // Example implementation with Firebase:
+    // try {
+    //   final GoogleSignIn googleSignIn = GoogleSignIn();
+    //   final GoogleSignInAccount? googleUser = await googleSignIn.signIn();
+    //   if (googleUser == null) {
+    //     return left(const AuthFailure.cancelledByUser());
+    //   }
+    //   final GoogleSignInAuthentication googleAuth = await googleUser.authentication;
+    //   final credential = GoogleAuthProvider.credential(
+    //     accessToken: googleAuth.accessToken,
+    //     idToken: googleAuth.idToken,
+    //   );
+    //   await _firebaseAuth.signInWithCredential(credential);
+    //   // Sync UserProfile similar to signInWithEmailAndPassword
+    //   return right(unit);
+    // } catch (e) {
+    //   return left(const AuthFailure.serverError());
+    // }
+    return right(unit);
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithApple() async {
+    // TODO: Implement Apple Sign-In
+    // Example implementation with Firebase:
+    // try {
+    //   final appleProvider = AppleAuthProvider();
+    //   final userCredential = await _firebaseAuth.signInWithProvider(appleProvider);
+    //   // Sync UserProfile similar to signInWithEmailAndPassword
+    //   return right(unit);
+    // } catch (e) {
+    //   if (e.code == 'sign_in_canceled') {
+    //     return left(const AuthFailure.cancelledByUser());
+    //   }
+    //   return left(const AuthFailure.serverError());
+    // }
+    return right(unit);
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithGoogle() async {
+    // TODO: Implement Google Registration
+    // For Google Sign-In, registration and sign-in are typically the same flow
+    // You can reuse the signInWithGoogle implementation or create a unified method
+    return await signInWithGoogle();
+  }
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithApple() async {
+    // TODO: Implement Apple Registration
+    // For Apple Sign-In, registration and sign-in are typically the same flow
+    // You can reuse the signInWithApple implementation or create a unified method
+    return await signInWithApple();
+  }
+
+  @override
+  Future<void> signOut() async {
+    await Future.wait(<Future<void>>[
+      // _firebaseAuth.signOut(), // Uncomment the following line to use Firebase Authentication
+      _storageRepository.removeToken(),
+    ]);
+  }
+}

generators/static/templates/auth/infrastructure/mock_auth_facade_template.jinja

@@ -0,0 +1,106 @@
+import 'dart:convert';
+
+import 'package:dartz/dartz.dart';
+import 'package:flutter/services.dart';
+import 'package:injectable/injectable.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:[[project_name]]/core/model/value_objects.dart';
+import 'package:[[project_name]]/domain/auth/model/auth_failure.dart';
+import 'package:[[project_name]]/domain/auth/model/i_auth_facade.dart';
+import 'package:[[project_name]]/domain/auth/model/user.dart' as auth_user;
+import 'package:[[project_name]]/domain/auth/model/value_objects.dart';
+import 'package:[[project_name]]/storage/storage_repository.dart';
+
+/// Mock authentication — any sign-in succeeds using [assets/mock/auth_user.json].
+@lazySingleton
+class MockAuthFacade implements IAuthFacade {
+  static const String _assetPath = 'assets/mock/auth_user.json';
+  static const String _userPrefsKey = 'mock_auth_user_json';
+
+  final StorageRepository _storageRepository;
+
+  MockAuthFacade(this._storageRepository);
+
+  Future<auth_user.User> _seedUser() async {
+    final String raw = await rootBundle.loadString(_assetPath);
+    final Map<String, dynamic> json = jsonDecode(raw) as Map<String, dynamic>;
+    return auth_user.User(
+      id: UniqueId.fromUniqueString(json['id'] as String),
+      name: StringSingleLine(json['name'] as String),
+      emailAddress: EmailAddress(json['emailAddress'] as String),
+    );
+  }
+
+  Future<void> _persistUser(auth_user.User user) async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.setString(
+      _userPrefsKey,
+      jsonEncode(<String, String>{
+        'id': user.id.getOrCrash(),
+        'name': user.name.getOrCrash(),
+        'emailAddress': user.emailAddress.getOrCrash(),
+      }),
+    );
+    await _storageRepository.saveToken(
+      const TokenData(token: 'mock-access-token', refreshToken: 'mock-refresh-token'),
+    );
+  }
+
+  Future<Option<auth_user.User>> _readUser() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final String? raw = prefs.getString(_userPrefsKey);
+    if (raw == null || raw.isEmpty) {
+      return none();
+    }
+    final Map<String, dynamic> json = jsonDecode(raw) as Map<String, dynamic>;
+    return some(
+      auth_user.User(
+        id: UniqueId.fromUniqueString(json['id'] as String),
+        name: StringSingleLine(json['name'] as String),
+        emailAddress: EmailAddress(json['emailAddress'] as String),
+      ),
+    );
+  }
+
+  Future<Either<AuthFailure, Unit>> _signIn() async {
+    final auth_user.User user = await _seedUser();
+    await _persistUser(user);
+    return right(unit);
+  }
+
+  @override
+  Future<Option<auth_user.User>> getSignedInUser() => _readUser();
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  }) =>
+      _signIn();
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  }) =>
+      _signIn();
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithGoogle() => _signIn();
+
+  @override
+  Future<Either<AuthFailure, Unit>> signInWithApple() => _signIn();
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithGoogle() => _signIn();
+
+  @override
+  Future<Either<AuthFailure, Unit>> registerWithApple() => _signIn();
+
+  @override
+  Future<void> signOut() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.remove(_userPrefsKey);
+    await _storageRepository.removeToken();
+  }
+}

generators/static/templates/auth/model/auth_failure_template.jinja

@@ -0,0 +1,11 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'auth_failure.freezed.dart';
+
+@freezed
+abstract class AuthFailure with _$AuthFailure {
+  const factory AuthFailure.cancelledByUser() = CancelledByUser;
+  const factory AuthFailure.serverError() = ServerError;
+  const factory AuthFailure.emailAlreadyInUse() = EmailAlreadyInUse;
+  const factory AuthFailure.invalidEmailAndPasswordCombination() = InvalidEmailAndPasswordCombination;
+}

generators/static/templates/auth/model/i_auth_facade_template.jinja

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import 'package:[[project_name]]/domain/auth/model/auth_failure.dart';
+import 'package:[[project_name]]/domain/auth/model/user.dart';
+import 'package:[[project_name]]/domain/auth/model/value_objects.dart';
+
+abstract class IAuthFacade {
+  /// Get the currently signed-in user
+  /// Returns User mapped from UserProfile (database entity)
+  /// The UserProfile is automatically synced with the authentication provider
+  Future<Option<User>> getSignedInUser();
+  Future<Either<AuthFailure, Unit>> registerWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  });
+  Future<Either<AuthFailure, Unit>> signInWithEmailAndPassword({
+    required EmailAddress emailAddress,
+    required Password password,
+  });
+  Future<Either<AuthFailure, Unit>> signInWithGoogle();
+  Future<Either<AuthFailure, Unit>> signInWithApple();
+  Future<Either<AuthFailure, Unit>> registerWithGoogle();
+  Future<Either<AuthFailure, Unit>> registerWithApple();
+  Future<void> signOut();
+}

generators/static/templates/auth/model/user_template.jinja

@@ -0,0 +1,34 @@
+/*
+ * User entity (authentication)
+ * 
+ * NOTE: This entity is used by AuthBloc and the authentication flow.
+ * It is mapped from UserProfile (database entity) which contains additional fields.
+ * 
+ * Flow: Auth → UserProfile sync → User (mapped)
+ * Both entities use the same ID (authId) for correlation.
+ */
+
+import 'package:dartz/dartz.dart';
+import 'package:flutter/foundation.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:[[project_name]]/domain/auth/model/value_objects.dart';
+import 'package:[[project_name]]/core/model/entity.dart';
+import 'package:[[project_name]]/core/model/failures.dart';
+import 'package:[[project_name]]/core/model/value_objects.dart';
+
+part 'user.freezed.dart';
+
+@freezed
+abstract class User with _$User implements IEntity {
+  const factory User({
+    required UniqueId id,
+    required StringSingleLine name,
+    required EmailAddress emailAddress,
+  }) = _User;
+}
+
+extension UserX on User {
+  Option<ValueFailure<dynamic>> get failureOption {
+    return name.failureOrUnit.andThen(emailAddress.failureOrUnit).fold((ValueFailure<dynamic> l) => some(l), (Unit r) => none());
+  }
+}

generators/static/templates/auth/model/value_objects_template.jinja

@@ -0,0 +1,54 @@
+import 'package:dartz/dartz.dart';
+import 'package:[[project_name]]/core/model/failures.dart';
+import 'package:[[project_name]]/core/model/value_objects.dart';
+import 'package:[[project_name]]/core/model/value_validators.dart';
+
+class EmailAddress extends ValueObject<String> {
+  @override
+  final Either<ValueFailure<String>, String> value;
+
+  factory EmailAddress(String input) {
+    return EmailAddress._(
+      validateEmailAddress(input),
+    );
+  }
+
+  const EmailAddress._(this.value);
+}
+
+class Password extends ValueObject<String> {
+  @override
+  final Either<ValueFailure<String>, String> value;
+
+  factory Password(String input) {
+    return Password._(
+      validatePassword(input),
+    );
+  }
+
+  String get rawValue {
+    return value.fold((ValueFailure<String> l) => l.failedValue, (String r) => r);
+  }
+
+  const Password._(this.value);
+}
+
+class ConfirmPassword extends ValueObject<String> {
+  @override
+  final Either<ValueFailure<String>, String> value;
+
+  factory ConfirmPassword(
+    String password,
+    String confirmPassword,
+  ) {
+    return ConfirmPassword._(
+      validateConfirmPassword(password, confirmPassword),
+    );
+  }
+
+  String get rawValue {
+    return value.fold((ValueFailure<String> l) => l.failedValue, (String r) => r);
+  }
+
+  const ConfirmPassword._(this.value);
+}

generators/static/templates/auth/presentation/login_screen_template.jinja

@@ -0,0 +1,24 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:[[project_name]]/features/auth/sign_in_form/application/sign_in_form_bloc.dart';
+import 'package:[[project_name]]/injection.dart';
+import 'package:[[project_name]]/features/auth/sign_in_form/presentation/sign_in_form.dart';
+import 'package:[[project_name]]/domain/auth/model/i_auth_facade.dart';
+
+class LoginPage extends StatelessWidget {
+  static const String routeName = '/login';
+  static const String logoHeroTag = 'auth-logo';
+
+  const LoginPage({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      backgroundColor: Colors.transparent,
+      body: BlocProvider<SignInFormBloc>(
+        create: (BuildContext context) => SignInFormBloc(getIt<IAuthFacade>()),
+        child: const SignInForm(),
+      ),
+    );
+  }
+}