kasy-cli 1.7.1 → 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.1",
+  "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

@@ -53,21 +53,58 @@ class _NotificationsPageState extends ConsumerState<NotificationsPage> {
 
   void requestReadAll() {
     _autoReadTimer?.cancel();
-    _autoReadTimer = Timer(const Duration(milliseconds: 1500), () {
+    _autoReadTimer = Timer(const Duration(seconds: 3), () {
       if (!mounted) return;
       ref.read(notificationsProvider.notifier).readAll();
     });
   }
 
-  bool _hasUnread(AsyncValue<NotificationsList> state) {
+  bool _hasAny(AsyncValue<NotificationsList> state) {
     if (!state.hasValue) return false;
-    return state.value!.data.any((n) => !n.seen);
+    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 hasUnread = _hasUnread(notificationsState);
+    final hasAny = _hasAny(notificationsState);
 
     return KasyOverlayScaffold(
       title: t.notifications.title,
@@ -77,17 +114,16 @@ class _NotificationsPageState extends ConsumerState<NotificationsPage> {
         builder: (ctx) => Row(
           mainAxisSize: MainAxisSize.min,
           children: [
-            if (hasUnread)
+            if (hasAny)
               KasyChromeOrbIconButton(
-                key: const Key('mark_all_read_button'),
-                icon: KasyIcons.check,
+                key: const Key('delete_all_button'),
+                icon: KasyIcons.trash,
                 iconSize: 18,
                 foregroundColor: ctx.colors.onSurface,
-                onPressed: () =>
-                    ref.read(notificationsProvider.notifier).readAll(),
-                tooltip: t.notifications.mark_all_read,
+                onPressed: () => _confirmAndDeleteAll(ctx),
+                tooltip: t.notifications.delete_all,
               ),
-            if (hasUnread) const SizedBox(width: KasySpacing.xs),
+            if (hasAny) const SizedBox(width: KasySpacing.xs),
             KasyChromeOrbIconButton(
               icon: KasyIcons.moreVert,
               iconSize: 18,
@@ -122,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),
                       ),
                   };
                 },
@@ -228,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

@@ -35,13 +35,14 @@ void main() {
 
   group('NotificationsPage — auto-read behavior', () {
     testWidgets(
-      'after 1.5s on screen, all notifications are marked as read',
+      'after 3s on screen, all notifications are marked as read',
       (tester) async {
         await tester.pumpPage(
           userState: authenticatedUser(),
           home: NotificationsPage(),
         );
-        await tester.pump(const Duration(milliseconds: 1600));
+        // Auto-read fires at 3000ms — give it a little headroom.
+        await tester.pump(const Duration(milliseconds: 3100));
         await tester.pumpAndSettle();
 
         final tiles = tester
@@ -61,9 +62,9 @@ void main() {
     );
   });
 
-  group('NotificationsPage — mark all read button', () {
+  group('NotificationsPage — delete all', () {
     testWidgets(
-      'tapping the button marks all notifications as read immediately',
+      'delete all button shows, opens confirm dialog, and clears the list',
       (tester) async {
         await tester.pumpPage(
           userState: authenticatedUser(),
@@ -71,23 +72,72 @@ void main() {
         );
         await tester.pumpAndSettle();
 
-        // Auto-read may have already run during pumpAndSettle.
-        // The button is hidden when no unread notifications remain — that is
-        // expected and itself a correct behavior.
-        final button = find.byKey(const Key('mark_all_read_button'));
-        if (button.evaluate().isNotEmpty) {
-          await tester.tap(button);
-          await tester.pumpAndSettle();
-        }
+        // Button is visible when there are notifications.
+        final deleteAllButton = find.byKey(const Key('delete_all_button'));
+        expect(deleteAllButton, findsOneWidget);
 
-        final tiles = tester
-            .widgetList<NotificationTileComponent>(
-              find.byType(NotificationTileComponent),
-            )
+        await tester.tap(deleteAllButton);
+        await tester.pumpAndSettle();
+
+        // 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(tiles, isNotEmpty);
-        for (final tile in tiles) {
-          expect(tile.notification.readAt, isNotNull);
+        expect(dismissibles, isNotEmpty);
+        for (final d in dismissibles) {
+          expect(d.direction, DismissDirection.endToStart);
+          expect(d.background, isNotNull);
         }
       },
     );