kasy-cli 1.2.1

package/templates/firebase/lib/core/data/api/remote_config_api.dart

@@ -0,0 +1,170 @@
+import 'package:firebase_remote_config/firebase_remote_config.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:logger/logger.dart';
+import 'package:sentry_flutter/sentry_flutter.dart';
+
+final remoteConfigApiProvider = Provider<RemoteConfigApi>(
+  (ref) {
+    final remoteConfigWrapper = RemoteConfigWrapper(
+      remoteConfig: FirebaseRemoteConfig.instance,
+    );
+    return RemoteConfigApi(
+      remoteConfig: FirebaseRemoteConfig.instance,
+      subscription: SubscriptionConfigs(
+        title: FirebaseRemoteConfigData<String>(
+          key: 'subscription_title',
+          api: remoteConfigWrapper,
+        ),
+      ),
+    );
+  },
+);
+
+/// RemoteConfigApi
+/// Firebase Remote Config is a cloud service that lets push configuration keys
+/// and values to your app for runtime parameterization
+/// It also provides
+/// - a web console to manage your keys and values
+/// - A/B testing (So you can test different values for a key)
+///
+/// Here it's abstracted to be able switching to another provider
+/// Also I don't like using directly String keys in the code
+/// So you create a class with all the keys you need and you can fetch them
+/// Instead of writing
+/// ```dart
+/// final title = _remoteConfig.getString('title');
+/// ```
+/// You write
+/// ```dart
+/// final title = remoteConfigApi.title.value;
+/// ```
+/// Also if you try to get a key that doesn't exist and have installed Sentry
+/// It will send an error to Sentry
+///
+/// Also you can use the default value if the key doesn't exist
+/// This force you to have a default value for each key
+/// And so a your app will not crash if you forget to add a key in the web console
+class RemoteConfigApi implements OnStartService {
+  final FirebaseRemoteConfig _remoteConfig;
+  final SubscriptionConfigs subscription; // this is an example of group of keys
+
+  RemoteConfigApi({
+    required FirebaseRemoteConfig remoteConfig,
+    required this.subscription,
+  }) : _remoteConfig = remoteConfig;
+
+  @override
+  Future<void> init() async {
+    try {
+      await _remoteConfig.setConfigSettings(RemoteConfigSettings(
+        fetchTimeout: const Duration(seconds: 60),
+        minimumFetchInterval: const Duration(hours: 1),
+      ));
+      await _remoteConfig.fetchAndActivate();
+    } catch (e) {
+      // Sometimes it fails to initialize the RemoteConfig
+      // So we just log the error and continue as this should not block the app
+      Logger().e("Error initializing RemoteConfig: $e");
+      Sentry.captureException(e, stackTrace: StackTrace.current);
+    }
+  }
+
+  Stream<OnKeyChanged> onKeyChanged() {
+    return _remoteConfig.onConfigUpdated.map((_) => () {});
+  }
+}
+
+/// this will be used to notify the app that a key has changed
+/// So you can update the UI
+typedef OnKeyChanged = void Function();
+
+/// This is a wrapper around FirebaseRemoteConfig
+/// It's used to be able to change this with another provider
+class RemoteConfigWrapper {
+  final FirebaseRemoteConfig _remoteConfig;
+
+  RemoteConfigWrapper({
+    required FirebaseRemoteConfig remoteConfig,
+  }) : _remoteConfig = remoteConfig;
+
+  String getString(String key) {
+    return _remoteConfig.getString(key);
+  }
+
+  int getInt(String key) {
+    return _remoteConfig.getInt(key);
+  }
+
+  double getDouble(String key) {
+    return _remoteConfig.getDouble(key);
+  }
+
+  bool getBool(String key) {
+    return _remoteConfig.getBool(key);
+  }
+
+  bool containsKey(String key) {
+    return _remoteConfig.getAll().containsKey(key);
+  }
+}
+
+abstract class RemoteConfigData<T> {
+  final String key;
+
+  RemoteConfigData({
+    required this.key,
+  });
+
+  T get value;
+
+  bool get exists;
+}
+
+/// This is the base of all our config items (title, description, etc...)
+class FirebaseRemoteConfigData<T> implements RemoteConfigData<T> {
+  final RemoteConfigWrapper _api;
+  final T? defaultValue;
+
+  @override
+  final String key;
+
+  FirebaseRemoteConfigData({
+    required this.key,
+    required RemoteConfigWrapper api,
+    this.defaultValue,
+  }) : _api = api;
+
+  @override
+  T get value {
+    
+    if (defaultValue != null && !exists) {
+      return defaultValue!;
+    }
+    if (T == String) {
+      return _api.getString(key) as T;
+    } else if (T == int) {
+      return _api.getInt(key) as T;
+    } else if (T == double) {
+      return _api.getDouble(key) as T;
+    } else if (T == bool) {
+      return _api.getBool(key) as T;
+    }
+    throw Exception('Type not supported');
+  }
+
+  @override
+  bool get exists => _api.containsKey(key);
+}
+
+/// this is an example of a group of keys
+/// I like to group them by feature
+/// So I can easily find them in the code
+class SubscriptionConfigs {
+  final RemoteConfigData<String> title;
+
+  SubscriptionConfigs({
+    required this.title,
+  });
+}
+

package/templates/firebase/lib/core/data/api/storage_api.dart

@@ -0,0 +1,115 @@
+import 'dart:async';
+
+import 'package:firebase_storage/firebase_storage.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/data/entities/upload_result.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:universal_io/io.dart';
+
+final storageApiProvider = Provider<StorageApi>((ref) => FirebaseStorageApi());
+
+abstract class StorageApi {
+  /// upload a file to firebase storage
+  /// and return a stream of the upload progress
+  Stream<UploadResult> uploadData(
+    Uint8List data,
+    String folder,
+    String filename, {
+    String? mimeType, // ex 'image/jpg'
+    bool isPublic = true,
+  });
+
+  /// request to delete a file from path
+  Future<void> deleteFile(String? path);
+}
+
+class FirebaseStorageApi implements StorageApi {
+  FirebaseStorageApi();
+
+  @override
+  Stream<UploadResult> uploadData(
+    Uint8List data,
+    String folder,
+    String filename, {
+    String? mimeType, // ex 'image/jpg'
+    bool isPublic = true,
+  }) async* {
+    final ref = FirebaseStorage.instance
+        .ref() //
+        .child(folder) //
+        .child('/$filename');
+    final metadata = SettableMetadata(contentType: mimeType);
+    final uploadTask = ref.putData(data, metadata);
+    await for (final event in uploadTask.snapshotEvents) {
+      final totalBytes = event.totalBytes;
+      final progress = totalBytes <= 0
+          ? 0.0
+          : event.bytesTransferred / totalBytes;
+      yield UploadResultProgress(_normalizeProgress(progress));
+      if (event.state == TaskState.success) {
+        break;
+      }
+    }
+    // Await the task to ensure the file is fully committed before fetching the URL.
+    final taskSnapshot = await uploadTask;
+    final imagePath = taskSnapshot.ref.fullPath;
+    if (!isPublic) {
+      yield UploadResultCompleted(imagePath: imagePath, imagePublicUrl: '');
+      return;
+    }
+    final publicUrl = await taskSnapshot.ref.getDownloadURL();
+    yield UploadResultCompleted(
+      imagePath: imagePath,
+      imagePublicUrl: publicUrl,
+    );
+  }
+
+  double _normalizeProgress(double progress) {
+    if (!progress.isFinite || progress <= 0) return 0.0;
+    if (progress >= 1) return 1.0;
+    return progress;
+  }
+
+  /// generate a public url for a file
+  /// without this function, the url is only accessible by the app
+  Future<UploadResultCompleted> generatePublicUrl(String path) {
+    return FirebaseStorage.instance
+        .ref(path)
+        .getDownloadURL()
+        .then(
+          (value) =>
+              UploadResultCompleted(imagePath: path, imagePublicUrl: value),
+        );
+  }
+
+  Stream<TaskSnapshot> downloadFile(String path) async* {
+    if (kIsWeb) {
+      throw UnsupportedError('File download to disk is not supported on web.');
+    }
+    // if (await Permission.storage.request().isDenied) {
+    //   throw "You must grant write permission to download files.";
+    // }
+    final fileRef = FirebaseStorage.instance.ref().child(path);
+    final fileName = fileRef.name;
+    Directory directory;
+    if (Platform.isAndroid) {
+      directory = Directory("/storage/emulated/0/Download");
+    } else {
+      directory = await getApplicationDocumentsDirectory();
+    }
+    final File destinationFile = File('${directory.path}/$fileName');
+    if (destinationFile.existsSync()) {
+      destinationFile.deleteSync();
+    }
+    destinationFile.createSync();
+    final task = fileRef.writeToFile(destinationFile);
+    yield* task.asStream();
+  }
+
+  @override
+  Future<void> deleteFile(String? path) async {
+    final ref = FirebaseStorage.instance.ref(path);
+    await ref.delete();
+  }
+}

package/templates/firebase/lib/core/data/api/tracking_api.dart

@@ -0,0 +1,119 @@
+import 'dart:async';
+
+import 'package:facebook_app_events/facebook_app_events.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/core/states/user_state_notifier.dart';
+import 'package:kasy_kit/features/notifications/repositories/device_repository.dart';
+import 'package:logger/logger.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:purchases_flutter/purchases_flutter.dart';
+import 'package:sentry_flutter/sentry_flutter.dart';
+
+final facebookEventApiProvider = Provider(
+  (ref) => FacebookEventApi(
+    deviceRepository: ref.watch(deviceRepositoryProvider),
+    userState: ref.watch(userStateNotifierProvider),
+  ),
+);
+
+class FacebookEventApi implements OnStartService {
+  final DeviceRepository deviceRepository;
+  final UserState userState;
+
+  FacebookEventApi({
+    required this.deviceRepository,
+    required this.userState,
+  });
+
+  @override
+  Future<void> init() async {
+    if (kIsWeb) {
+      return;
+    }
+    // We must init the facebook app events
+    final facebookAppEvents = FacebookAppEvents();
+    // This is required by RevenueCat
+    await facebookAppEvents.setAutoLogAppEventsEnabled(false);
+  }
+
+  Future<void> initUser(String userId) async {
+    if (kIsWeb) {
+      return;
+    }
+    final facebookAppEvents = FacebookAppEvents();
+    await facebookAppEvents.setUserID(userId);
+
+    if (defaultTargetPlatform != TargetPlatform.iOS) {
+      return;
+    }
+    final isGranted = await Permission.appTrackingTransparency.isGranted;
+    if (!isGranted) {
+      return;
+    }
+    await facebookAppEvents.setAdvertiserTracking(enabled: true);
+  }
+
+  Future<void> requestIDFA() async {
+    if (kIsWeb) {
+      return;
+    }
+    final facebookAppEvents = FacebookAppEvents();
+    if (defaultTargetPlatform == TargetPlatform.iOS) {
+      final status = await Permission.appTrackingTransparency.request();
+      // analyticsApi?.logEvent('att_request', {
+      //   'granted': true,
+      // });
+
+      debugPrint("IDFA status: $status");
+      if (status.isGranted) {
+        // collect identifiers for REVENUECAT
+        await Purchases.collectDeviceIdentifiers();
+        await facebookAppEvents.setAdvertiserTracking(enabled: true);
+        await _initMetaUser();
+        unawaited(facebookAppEvents.flush());
+        await deviceRepository.refreshExtraData();
+      } else { 
+        await facebookAppEvents.setAdvertiserTracking(enabled: false);
+      }
+    } else if (defaultTargetPlatform == TargetPlatform.android) {
+      await _initMetaUser();
+      await facebookAppEvents.setAutoLogAppEventsEnabled(true);
+    }
+  }
+
+  Future<void> _initMetaUser() async {
+    final facebookAppEvents = FacebookAppEvents();
+    final userId = userState.user.idOrNull;
+    if (userId != null) {
+      await facebookAppEvents.setUserID(userId);
+    }
+    final userAnonId = await facebookAppEvents.getAnonymousId();
+    
+    if (userAnonId != null) {
+      await Purchases.setFBAnonymousID(userAnonId);
+    }
+  }
+
+  Future<void> logMetaStartTrial(String orderId, double price, String currency) async {
+    try {
+      final facebookAppEvents = FacebookAppEvents();
+      await facebookAppEvents.logStartTrial(orderId: orderId, price: price, currency: currency);
+    } catch (e) {
+      Logger().e("Error logging StartTrial (facebook): $e");
+      Sentry.captureException(e, stackTrace: StackTrace.current);
+    }
+  }
+
+  Future<void> logMetaSubscribe(String orderId, double price, String currency) async {
+    try {
+      final facebookAppEvents = FacebookAppEvents();
+      await facebookAppEvents.logSubscribe(orderId: orderId, price: price, currency: currency);
+    } catch (e) {
+      Logger().e("Error logging Subscribe (facebook): $e");
+      Sentry.captureException(e, stackTrace: StackTrace.current);
+    }
+  }
+}

package/templates/firebase/lib/core/data/api/user_api.dart

@@ -0,0 +1,115 @@
+import 'dart:typed_data';
+
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:cloud_functions/cloud_functions.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/firestore_retry.dart';
+import 'package:kasy_kit/core/data/api/storage_api.dart';
+import 'package:kasy_kit/core/data/entities/upload_result.dart';
+import 'package:kasy_kit/core/data/entities/user_entity.dart';
+import 'package:logger/logger.dart';
+
+final userApiProvider = Provider<UserApi>(
+  (ref) => UserApi(
+    client: FirebaseFirestore.instance,
+    firebaseFunctions: FirebaseFunctions.instanceFor(
+      region: 'europe-west1',
+    ), // region token — replaced by kasy at project generation (see cli/lib/scaffold/backends/firebase/tokens.js)
+    storageApi: ref.read(storageApiProvider),
+  ),
+);
+
+class UserApi {
+  final FirebaseFirestore _client;
+  final FirebaseFunctions _firebaseFunctions;
+  final Logger _logger;
+  final StorageApi _storageApi;
+
+  UserApi({
+    required FirebaseFirestore client,
+    required FirebaseFunctions firebaseFunctions,
+    required StorageApi storageApi,
+  }) : _client = client,
+       _logger = Logger(),
+       _firebaseFunctions = firebaseFunctions,
+       _storageApi = storageApi;
+
+  CollectionReference<UserEntity?> get _collection => _client
+      .collection('users')
+      .withConverter(
+        fromFirestore: (snapshot, _) {
+          if (snapshot.exists) {
+            return UserEntity.fromJson(snapshot.id, snapshot.data()!);
+          }
+          return null;
+        },
+        toFirestore: (data, _) => data!.toJson(),
+      );
+
+  Future<UserEntity?> get(String id) {
+    return retryOnFirestoreUnavailable(
+      () => _collection.doc(id).get().then((value) => value.data()),
+    );
+  }
+
+  Future<void> update(UserEntity user) {
+    final data = user.toJson();
+    data.removeWhere((key, value) => value == null);
+    return _collection.doc(user.id).update(data);
+  }
+
+  Future<void> delete(String id) {
+    return _collection.doc(id).delete();
+  }
+
+  /// Delete the current user account
+  /// As you can't delete a user authentification from the client
+  /// we use a cloud function to delete the user
+  /// This is required to publish any mobile app on the store (apple, google)
+  /// User has to be able to delete their account
+  Future<void> deleteMe() async {
+    try {
+      final callable = _firebaseFunctions.httpsCallable(
+        'authFunctions-deleteUserAccount',
+      );
+      await callable.call();
+    } catch (err, stacktrace) {
+      _logger.e("delete user error $err", stackTrace: stacktrace);
+      throw ApiError(message: "Error while deleting user");
+    }
+  }
+
+  Future<void> create(UserEntity user) async {
+    if (user.id == null) {
+      throw Exception('User id cannot be null');
+    }
+    await _collection.doc(user.id).set(user);
+  }
+
+  Stream<UploadResult> updateAvatar(String userId, Uint8List data) async* {
+    final task = _storageApi.uploadData(
+      data,
+      'users/$userId/avatar',
+      'thumb.jpg',
+      mimeType: 'image/jpg',
+    );
+    await for (final res in task) {
+      if (res case UploadResultCompleted()) {
+        await _collection.doc(userId).update({
+          "avatarPath": res.imagePublicUrl,
+        });
+      }
+      yield res;
+    }
+  }
+
+  Future<void> deleteAvatar(String userId) async {
+    await _storageApi.deleteFile('users/$userId/avatar/thumb.jpg');
+    await _collection.doc(userId).update({'avatarPath': null});
+  }
+
+  Future<void> updateLocale(String userId, String locale) {
+    return _collection.doc(userId).update({'locale': locale});
+  }
+}

package/templates/firebase/lib/core/data/entities/json_converters.dart

@@ -0,0 +1,39 @@
+// ignore_for_file: avoid_classes_with_only_static_members
+
+// import 'package:cloud_firestore/cloud_firestore.dart';
+// import 'package:freezed_annotation/freezed_annotation.dart';
+
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+class Converters {
+  static String? id(String? id) => null;
+}
+
+class TimestampConverter implements JsonConverter<DateTime, Timestamp> {
+  const TimestampConverter();
+
+  @override
+  DateTime fromJson(Timestamp timestamp) {
+    return timestamp.toDate();
+  }
+
+  @override
+  Timestamp toJson(DateTime date) => Timestamp.fromDate(date);
+}
+
+class TimestampListConverter
+    implements JsonConverter<List<DateTime>, List<dynamic>> {
+  const TimestampListConverter();
+
+  @override
+  List<DateTime> fromJson(List<dynamic> timestamps) {
+    return timestamps
+        .map((timestamp) => (timestamp as Timestamp).toDate())
+        .toList();
+  }
+
+  @override
+  List<dynamic> toJson(List<DateTime> dates) =>
+      dates.map((date) => Timestamp.fromDate(date)).toList();
+}

package/templates/firebase/lib/core/data/entities/upload_result.dart

@@ -0,0 +1,48 @@
+sealed class UploadResult {}
+
+class UploadResultProgress extends UploadResult {
+  final double progress;
+
+  UploadResultProgress(
+    this.progress,
+  );
+
+  @override
+  String toString() => 'UploadResultProgress($progress)';
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+
+    return other is UploadResultProgress && other.progress == progress;
+  }
+
+  @override
+  int get hashCode => progress.hashCode;
+}
+
+class UploadResultCompleted extends UploadResult {
+  final String imagePath;
+  final String imagePublicUrl;
+
+  UploadResultCompleted({
+    required this.imagePath,
+    required this.imagePublicUrl,
+  });
+
+  @override
+  String toString() =>
+      'UploadResultCompleted(imagePath: $imagePath, imagePublicUrl: $imagePublicUrl)';
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+
+    return other is UploadResultCompleted &&
+        other.imagePath == imagePath &&
+        other.imagePublicUrl == imagePublicUrl;
+  }
+
+  @override
+  int get hashCode => imagePath.hashCode ^ imagePublicUrl.hashCode;
+}

package/templates/firebase/lib/core/data/entities/user_entity.dart

@@ -0,0 +1,54 @@
+// ignore: depend_on_referenced_packages
+// ignore_for_file: invalid_annotation_target
+
+// ignore: unused_import
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:kasy_kit/core/data/entities/json_converters.dart';
+
+part 'user_entity.freezed.dart';
+part 'user_entity.g.dart';
+
+@freezed
+sealed class UserEntity with _$UserEntity {
+  const factory UserEntity({
+    @JsonKey(includeIfNull: false, toJson: Converters.id) String? id,
+    @JsonKey(name: 'creation_date')
+    @TimestampConverter()
+    DateTime? creationDate,
+    @JsonKey(name: 'last_update_date')
+    @TimestampConverter()
+    DateTime? lastUpdateDate,
+    String? name,
+    String? email,
+    String? avatarPath,
+    bool? onboarded,
+    String? locale,
+  }) = UserEntityData;
+
+  const UserEntity._();
+
+  factory UserEntity.fromJson(String id, Map<String, dynamic> json) =>
+      _$UserEntityFromJson(json..['id'] = id);
+}
+
+class Credentials {
+  // this is the user id
+  final String id;
+  final String? token;
+
+  Credentials({
+    required this.id,
+    required this.token,
+  });
+
+  factory Credentials.fromJson(Map<String, Object?> json) {
+    if (!json.containsKey('id') || !json.containsKey('token')) {
+      throw Exception('Invalid credentials');
+    }
+    return Credentials(
+      id: json['id']! as String,
+      token: json['token']! as String,
+    );
+  }
+}

package/templates/firebase/lib/core/data/models/pageable.dart

@@ -0,0 +1,12 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'pageable.freezed.dart';
+
+@freezed
+sealed class Pageable<T> with _$Pageable<T> {
+  const factory Pageable({
+    required int page,
+    required int pageSize,
+    required List<T> data,
+  }) = _Pageable<T>;
+}