kasy-cli 1.7.0 → 1.8.0

package/lib/scaffold/backends/api/patch/lib/features/notifications/api/notifications_api.dart

@@ -52,6 +52,9 @@ abstract class NotificationsApi {
   // Used to mark a notification as read
   Future<void> read(String userId, String notificationId);
 
+  // Used to delete a single notification (per-user only)
+  Future<void> delete(String userId, String notificationId);
+
   // Used to get the unread notifications count
   Stream<int> unreadNotifications(String userId);
 
@@ -196,6 +199,22 @@ class FirebaseNotificationsApi implements NotificationsApi {
     }
   }
 
+  @override
+  Future<void> delete(String userId, String notificationId) async {
+    try {
+      final _ = await _client.delete(
+        '/users/$userId/notifications/$notificationId',
+      );
+    } on DioException catch (e) {
+      throw ApiError.fromDioException(e);
+    } catch (e, stacktrace) {
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
   @override
   Stream<int> unreadNotifications(String userId) async* {
     try {

package/lib/scaffold/backends/supabase/patch/lib/features/notifications/api/notifications_api.dart

@@ -49,6 +49,9 @@ abstract class NotificationsApi {
   // Used to mark a notification as read
   Future<void> read(String userId, String notificationId);
 
+  // Used to delete a single notification (per-user only)
+  Future<void> delete(String userId, String notificationId);
+
   // Used to get the unread notifications count
   Stream<int> unreadNotifications(String userId);
 
@@ -197,6 +200,22 @@ class FirebaseNotificationsApi implements NotificationsApi {
     }
   }
 
+  @override
+  Future<void> delete(String userId, String notificationId) async {
+    try {
+      await _client
+          .from('notifications')
+          .delete()
+          .eq('user_id', userId)
+          .eq('id', notificationId);
+    } catch (e, stacktrace) {
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
   @override
   Stream<int> unreadNotifications(String userId) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kasy-cli",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "CLI for scaffolding production-ready Flutter SaaS apps with Firebase, Supabase, or API REST backends.",
   "bin": {
     "kasy": "./bin/kasy.js"

package/templates/firebase/lib/features/notifications/api/notifications_api.dart

@@ -46,6 +46,8 @@ abstract class NotificationsApi {
 
   // Used to mark a notification as read
   Future<void> read(String userId, String notificationId);
+  // Used to delete a single notification (per-user only)
+  Future<void> delete(String userId, String notificationId);
   // Used to get the unread notifications count
   Stream<int> unreadNotifications(String userId);
 
@@ -196,6 +198,18 @@ class FirebaseNotificationsApi implements NotificationsApi {
     }
   }
 
+  @override
+  Future<void> delete(String userId, String notificationId) async {
+    try {
+      await _collection(userId).doc(notificationId).delete();
+    } catch (e, stacktrace) {
+      throw ApiError(
+        code: 0,
+        message: '$e: $stacktrace',
+      );
+    }
+  }
+
   @override
   Stream<int> unreadNotifications(String userId) async* {
     // count() aggregation: 1 read per 1000 docs counted (vs N reads for full snapshot).

package/templates/firebase/lib/features/notifications/providers/notifications_provider.dart

@@ -67,6 +67,47 @@ class NotificationsNotifier extends _$NotificationsNotifier {
     }
   }
 
+  /// Delete a single notification. Optimistically removes from state, then
+  /// persists the deletion on the server. Reverts on failure.
+  Future<void> delete(Notification notification) async {
+    if (!state.hasValue) return;
+    final notificationRepository = ref.read(notificationRepositoryProvider);
+    final userId = ref.read(userStateNotifierProvider).user.idOrNull;
+    if (userId == null) return;
+    final previous = state.value!;
+    state = AsyncValue.data(
+      previous.copyWith(
+        data: previous.data.where((n) => n.id != notification.id).toList(),
+      ),
+    );
+    try {
+      await notificationRepository.delete(userId, notification);
+    } catch (e) {
+      Logger().e("delete error $e");
+      state = AsyncValue.data(previous);
+    }
+  }
+
+  /// Delete every notification currently loaded. Optimistically clears state,
+  /// then persists deletions on the server. Reverts on failure.
+  Future<void> deleteAll() async {
+    if (!state.hasValue) return;
+    final notificationRepository = ref.read(notificationRepositoryProvider);
+    final userId = ref.read(userStateNotifierProvider).user.idOrNull;
+    if (userId == null) return;
+    final previous = state.value!;
+    if (previous.data.isEmpty) return;
+    state = AsyncValue.data(previous.copyWith(data: const []));
+    try {
+      await Future.wait(
+        previous.data.map((n) => notificationRepository.delete(userId, n)),
+      );
+    } catch (e) {
+      Logger().e("deleteAll error $e");
+      state = AsyncValue.data(previous);
+    }
+  }
+
   Future<void> refresh() async {
     if (_locked) return;
     _locked = true;

package/templates/firebase/lib/features/notifications/repositories/notifications_repository.dart

@@ -25,6 +25,9 @@ abstract class NotificationsRepository implements OnStartService {
   // mark a notification as read
   Future<Notification> read(String userId, Notification notification);
 
+  // delete a single notification (per-user only)
+  Future<void> delete(String userId, Notification notification);
+
   // listen to the unread notifications count
   Stream<int> listenToUnreadNotificationsCount(String userId);
 
@@ -207,6 +210,14 @@ class AppNotificationsRepository implements NotificationsRepository {
     return notification.copyWith(readAt: DateTime.now());
   }
 
+  @override
+  Future<void> delete(String userId, Notification notification) async {
+    if (notification.id == null) {
+      throw Exception('A notification without id cannot be deleted');
+    }
+    await _notificationsApi.delete(userId, notification.id!);
+  }
+
   @override
   Stream<int> listenToUnreadNotificationsCount(String userId) {
     return _notificationsApi.unreadNotifications(userId);

package/templates/firebase/lib/features/notifications/ui/notifications_page.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
@@ -5,6 +7,7 @@ import 'package:kasy_kit/components/kasy_app_bar.dart';
 import 'package:kasy_kit/core/theme/theme.dart';
 import 'package:kasy_kit/features/notifications/providers/models/notification.dart'
     as app;
+import 'package:kasy_kit/features/notifications/providers/models/notification_list.dart';
 import 'package:kasy_kit/features/notifications/providers/notifications_provider.dart';
 import 'package:kasy_kit/features/notifications/ui/components/notification_settings_sheet.dart';
 import 'package:kasy_kit/features/notifications/ui/components/notification_tile.dart';
@@ -19,6 +22,7 @@ class NotificationsPage extends ConsumerStatefulWidget {
 
 class _NotificationsPageState extends ConsumerState<NotificationsPage> {
   final ScrollController _scrollController = ScrollController();
+  Timer? _autoReadTimer;
 
   @override
   void initState() {
@@ -29,6 +33,7 @@ class _NotificationsPageState extends ConsumerState<NotificationsPage> {
 
   @override
   void dispose() {
+    _autoReadTimer?.cancel();
     _scrollController.removeListener(_onScrollChange);
     _scrollController.dispose();
     super.dispose();
@@ -47,27 +52,86 @@ class _NotificationsPageState extends ConsumerState<NotificationsPage> {
   }
 
   void requestReadAll() {
-    Future.delayed(const Duration(seconds: 3), () {
-      if (!ref.context.mounted) return;
+    _autoReadTimer?.cancel();
+    _autoReadTimer = Timer(const Duration(seconds: 3), () {
+      if (!mounted) return;
       ref.read(notificationsProvider.notifier).readAll();
     });
   }
 
+  bool _hasAny(AsyncValue<NotificationsList> state) {
+    if (!state.hasValue) return false;
+    return state.value!.data.isNotEmpty;
+  }
+
+  Future<void> _confirmAndDeleteAll(BuildContext context) async {
+    final tr = t.notifications;
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (dialogCtx) => AlertDialog(
+        title: Text(tr.delete_all_confirm_title),
+        content: Text(tr.delete_all_confirm_message),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(dialogCtx).pop(false),
+            child: Text(tr.cancel_action),
+          ),
+          TextButton(
+            onPressed: () => Navigator.of(dialogCtx).pop(true),
+            style: TextButton.styleFrom(foregroundColor: context.colors.error),
+            child: Text(tr.delete_action),
+          ),
+        ],
+      ),
+    );
+    if (confirmed != true || !context.mounted) return;
+    await ref.read(notificationsProvider.notifier).deleteAll();
+    if (!context.mounted) return;
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(tr.deleted_all)),
+    );
+  }
+
+  Future<void> _deleteOne(BuildContext context, app.Notification n) async {
+    final tr = t.notifications;
+    await ref.read(notificationsProvider.notifier).delete(n);
+    if (!context.mounted) return;
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(tr.deleted_one)),
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final notificationsState = ref.watch(notificationsProvider);
+    final hasAny = _hasAny(notificationsState);
 
     return KasyOverlayScaffold(
       title: t.notifications.title,
       appBarStyle: KasyAppBarStyle.rootTab,
       scrollController: _scrollController,
       trailing: Builder(
-        builder: (ctx) => KasyChromeOrbIconButton(
-          icon: KasyIcons.moreVert,
-          iconSize: 18,
-          foregroundColor: ctx.colors.onSurface,
-          onPressed: () => showNotificationSettingsSheet(ctx),
-          tooltip: 'Opções',
+        builder: (ctx) => Row(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            if (hasAny)
+              KasyChromeOrbIconButton(
+                key: const Key('delete_all_button'),
+                icon: KasyIcons.trash,
+                iconSize: 18,
+                foregroundColor: ctx.colors.onSurface,
+                onPressed: () => _confirmAndDeleteAll(ctx),
+                tooltip: t.notifications.delete_all,
+              ),
+            if (hasAny) const SizedBox(width: KasySpacing.xs),
+            KasyChromeOrbIconButton(
+              icon: KasyIcons.moreVert,
+              iconSize: 18,
+              foregroundColor: ctx.colors.onSurface,
+              onPressed: () => showNotificationSettingsSheet(ctx),
+              tooltip: 'Opções',
+            ),
+          ],
         ),
       ),
       onRefresh: () async {
@@ -94,12 +158,13 @@ class _NotificationsPageState extends ConsumerState<NotificationsPage> {
                   return switch (item) {
                     _HeaderItem(:final label) => _GroupLabel(label: label),
                     _TileItem(:final notification, :final animationIndex) =>
-                      NotificationTileComponent(
+                      _SwipeToDeleteTile(
                         notification: notification,
                         index: animationIndex,
                         onTap: (n) => ref
                             .read(notificationsProvider.notifier)
                             .onTapNotification(n),
+                        onDismissed: (n) => _deleteOne(context, n),
                       ),
                   };
                 },
@@ -200,3 +265,39 @@ class _GroupLabel extends StatelessWidget {
     );
   }
 }
+
+/// Wraps [NotificationTileComponent] in a [Dismissible] so the user can
+/// swipe a notification to the left to delete it.
+class _SwipeToDeleteTile extends StatelessWidget {
+  final app.Notification notification;
+  final int index;
+  final void Function(app.Notification) onTap;
+  final void Function(app.Notification) onDismissed;
+
+  const _SwipeToDeleteTile({
+    required this.notification,
+    required this.index,
+    required this.onTap,
+    required this.onDismissed,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Dismissible(
+      key: ValueKey('notification_${notification.id ?? index}'),
+      direction: DismissDirection.endToStart,
+      background: Container(
+        alignment: Alignment.centerRight,
+        padding: const EdgeInsets.symmetric(horizontal: KasySpacing.lg),
+        color: context.colors.error,
+        child: Icon(KasyIcons.trash, color: context.colors.onError),
+      ),
+      onDismissed: (_) => onDismissed(notification),
+      child: NotificationTileComponent(
+        notification: notification,
+        index: index,
+        onTap: onTap,
+      ),
+    );
+  }
+}

package/templates/firebase/lib/i18n/en.i18n.json

@@ -438,7 +438,14 @@
         "group_today": "Today",
         "group_yesterday": "Yesterday",
         "group_older": "Older",
-        "empty_cta": "Enable notifications"
+        "empty_cta": "Enable notifications",
+        "delete_all": "Delete all",
+        "delete_all_confirm_title": "Delete all notifications?",
+        "delete_all_confirm_message": "This will permanently remove every notification from your account. This cannot be undone.",
+        "delete_action": "Delete",
+        "cancel_action": "Cancel",
+        "deleted_one": "Notification deleted",
+        "deleted_all": "All notifications deleted"
     },
     "bottom_router": {
         "fake_page_text": "This is a fake page"

package/templates/firebase/lib/i18n/es.i18n.json

@@ -438,7 +438,14 @@
         "group_today": "Hoy",
         "group_yesterday": "Ayer",
         "group_older": "Más antiguas",
-        "empty_cta": "Activar notificaciones"
+        "empty_cta": "Activar notificaciones",
+        "delete_all": "Eliminar todo",
+        "delete_all_confirm_title": "¿Eliminar todas las notificaciones?",
+        "delete_all_confirm_message": "Esto eliminará todas las notificaciones de tu cuenta. Esta acción no se puede deshacer.",
+        "delete_action": "Eliminar",
+        "cancel_action": "Cancelar",
+        "deleted_one": "Notificación eliminada",
+        "deleted_all": "Todas las notificaciones eliminadas"
     },
     "bottom_router": {
         "fake_page_text": "Esta es una página de prueba"

package/templates/firebase/lib/i18n/pt.i18n.json

@@ -438,7 +438,14 @@
         "group_today": "Hoje",
         "group_yesterday": "Ontem",
         "group_older": "Mais antigas",
-        "empty_cta": "Ativar notificações"
+        "empty_cta": "Ativar notificações",
+        "delete_all": "Excluir tudo",
+        "delete_all_confirm_title": "Excluir todas as notificações?",
+        "delete_all_confirm_message": "Isso vai remover todas as notificações da sua conta. Essa ação não pode ser desfeita.",
+        "delete_action": "Excluir",
+        "cancel_action": "Cancelar",
+        "deleted_one": "Notificação excluída",
+        "deleted_all": "Todas as notificações foram excluídas"
     },
     "bottom_router": {
         "fake_page_text": "Esta é uma página de exemplo"

package/templates/firebase/test/features/notifications/data/notifications_api_fake.dart

@@ -44,6 +44,11 @@ class FakeNotificationsApi implements NotificationsApi {
     return Future.value();
   }
 
+  @override
+  Future<void> delete(String userId, String notificationId) {
+    return Future.value();
+  }
+
   @override
   Stream<int> unreadNotifications(String userId) {
     return Stream.value(1);

package/templates/firebase/test/features/notifications/ui/notifications_page_test.dart

@@ -1,3 +1,4 @@
+import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:kasy_kit/core/data/models/user.dart';
 import 'package:kasy_kit/core/states/models/user_state.dart';
@@ -8,61 +9,136 @@ import 'package:kasy_kit/features/notifications/ui/widgets/notification_tile.dar
 import '../../../test_utils.dart';
 
 void main() {
-  group('User is connected', () {
+  UserState authenticatedUser() => UserState(
+    user: User.authenticated(
+      id: '1',
+      email: 'user@email.com',
+      name: 'user name',
+      onboarded: true,
+      creationDate: DateTime.now().subtract(const Duration(days: 4)),
+    ),
+  );
+
+  group('NotificationsPage — rendering', () {
+    testWidgets('renders title and notification tiles', (tester) async {
+      await tester.pumpPage(
+        userState: authenticatedUser(),
+        home: NotificationsPage(),
+      );
+      await tester.pumpAndSettle();
+
+      expect(find.byType(NotificationsPage), findsOneWidget);
+      expect(find.text('Notifications'), findsOneWidget);
+      expect(find.byType(NotificationTile), findsAtLeastNWidgets(3));
+    });
+  });
+
+  group('NotificationsPage — auto-read behavior', () {
     testWidgets(
-      'Load notifications => should show 20 notifications',
+      'after 3s on screen, all notifications are marked as read',
       (tester) async {
         await tester.pumpPage(
-          userState: UserState(
-            user: User.authenticated(
-              id: '1',
-              email: 'user@email.com',
-              name: 'user name',
-              onboarded: true,
-              creationDate: DateTime.now().subtract(const Duration(days: 4)),
-            ),
-          ),
+          userState: authenticatedUser(),
           home: NotificationsPage(),
         );
-        await tester.pump(const Duration(seconds: 3));
+        // Auto-read fires at 3000ms — give it a little headroom.
+        await tester.pump(const Duration(milliseconds: 3100));
         await tester.pumpAndSettle();
-        expect(find.byType(NotificationsPage), findsOneWidget);
-        expect(find.text("Notifications"), findsOneWidget);
-        expect(find.byType(NotificationTile), findsAtLeastNWidgets(3));
+
+        final tiles = tester
+            .widgetList<NotificationTileComponent>(
+              find.byType(NotificationTileComponent),
+            )
+            .toList();
+        expect(tiles, isNotEmpty);
+        for (final tile in tiles) {
+          expect(
+            tile.notification.readAt,
+            isNotNull,
+            reason: 'All notifications should be read after auto-read fires',
+          );
+        }
       },
     );
+  });
 
+  group('NotificationsPage — delete all', () {
     testWidgets(
-      'Load notifications, wait 3 seconds => all notifications are now read',
+      'delete all button shows, opens confirm dialog, and clears the list',
       (tester) async {
         await tester.pumpPage(
-          userState: UserState(
-            user: User.authenticated(
-              id: '1',
-              email: 'user@email.com',
-              name: 'user name',
-              onboarded: true,
-              creationDate: DateTime.now().subtract(const Duration(days: 4)),
-            ),
-          ),
+          userState: authenticatedUser(),
           home: NotificationsPage(),
         );
-        var firstNotification = tester.firstWidget<NotificationTileComponent>(
-          find.byType(NotificationTileComponent),
-        );
-        expect(firstNotification.notification.readAt, isNull);
+        await tester.pumpAndSettle();
+
+        // Button is visible when there are notifications.
+        final deleteAllButton = find.byKey(const Key('delete_all_button'));
+        expect(deleteAllButton, findsOneWidget);
 
-        await tester.pump(const Duration(seconds: 3));
+        await tester.tap(deleteAllButton);
         await tester.pumpAndSettle();
-        firstNotification = tester.firstWidget<NotificationTileComponent>(
-          find.byType(NotificationTileComponent),
-        );
 
-        expect(
-          firstNotification.notification.readAt,
-          isNotNull,
-          reason: "All notifications should be read after 3 seconds",
+        // Confirm dialog appears with destructive action.
+        expect(find.text('Delete all notifications?'), findsOneWidget);
+        expect(find.text('Delete'), findsOneWidget);
+        expect(find.text('Cancel'), findsOneWidget);
+
+        await tester.tap(find.text('Delete'));
+        await tester.pumpAndSettle();
+
+        // After deletion, no notification tiles remain.
+        expect(find.byType(NotificationTileComponent), findsNothing);
+      },
+    );
+
+    testWidgets('cancel on confirm dialog keeps notifications intact',
+        (tester) async {
+      await tester.pumpPage(
+        userState: authenticatedUser(),
+        home: NotificationsPage(),
+      );
+      await tester.pumpAndSettle();
+
+      final countBefore = tester
+          .widgetList<NotificationTileComponent>(
+            find.byType(NotificationTileComponent),
+          )
+          .length;
+      expect(countBefore, greaterThan(0));
+
+      await tester.tap(find.byKey(const Key('delete_all_button')));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Cancel'));
+      await tester.pumpAndSettle();
+
+      final countAfter = tester
+          .widgetList<NotificationTileComponent>(
+            find.byType(NotificationTileComponent),
+          )
+          .length;
+      expect(countAfter, countBefore);
+    });
+  });
+
+  group('NotificationsPage — swipe to delete', () {
+    testWidgets(
+      'each tile is wrapped in a Dismissible configured for left-swipe',
+      (tester) async {
+        await tester.pumpPage(
+          userState: authenticatedUser(),
+          home: NotificationsPage(),
         );
+        await tester.pumpAndSettle();
+
+        final dismissibles = tester
+            .widgetList<Dismissible>(find.byType(Dismissible))
+            .toList();
+        expect(dismissibles, isNotEmpty);
+        for (final d in dismissibles) {
+          expect(d.direction, DismissDirection.endToStart);
+          expect(d.background, isNotNull);
+        }
       },
     );
   });