eletrotupi/tcc — api: rename the notification mute to pushEnabled • pira

eletrotupi / tcc/ commit / 30f98b8

api: rename the notification mute to pushEnabled

The preference only ever stopped delivery, so it is now named for what
it does: a push-scoped mute, renamed in place so the column keeps its
values. The daily reminder is scheduled whenever a time is set, which
lets someone who silences push keep the record in the app, and Settings
splits the two into independent rows

Pedro Lucas Porcellis porcellis@eletrotupi.com · 11 days ago 30f98b88ba3e0926a1a93ed3c7a9e2618d9ff920 Browse files

Parents dafa6f8

Changed files

Additions

+127

Deletions

-43

api/prisma/migrations/20261017033204_rename_notifications_enabled_to_push_enabled/migration.sql added+3 
/dev/null → api/prisma/migrations/20261017033204_rename_notifications_enabled_to_push_enabled/migration.sql
  + -- The preference gates push only, so it is named for what it does. A rename,
  + -- not a drop and add: the column keeps its values.
  + ALTER TABLE "users" RENAME COLUMN "notifications_enabled" TO "push_enabled";
api/prisma/schema.prisma modified+1 -1
api/prisma/schema.prisma
    generator client {
      provider = "prisma-client-js"
      //output   = "../src/generated/prisma"
    }
    
      activationCode          String?   @unique @map("activation_code")
      activationCodeExpiresAt DateTime? @map("activation_code_expires_at")
      active                  Boolean   @default(false) @map("active")
    
      pushToken            String?  @map("push_token")
  -   notificationsEnabled Boolean  @default(true) @map("notifications_enabled")
  +   pushEnabled          Boolean  @default(true) @map("push_enabled")
      dailyReminderTime    String?  @map("daily_reminder_time")
      weeklyResumeEnabled  Boolean  @default(false) @map("weekly_resume_enabled")
    
      onboardingSeenAt DateTime? @map("onboarding_seen_at")
      termsAcceptedAt  DateTime? @map("terms_accepted_at")
      THREE_TIMES_DAILY
      WEEKLY
      BIWEEKLY
      MONTHLY
    }
api/src/lib/serializers/user.ts modified+2 -2
api/src/lib/serializers/user.ts
    import { Prisma, User } from '@prisma/client';
    
    // DB-level projection of the allow-list below — keep the two in sync.
    export const publicUserSelect = {
      id: true,
      lastName: true,
      updatedAt: true,
      avatarKey: true,
      avatarURL: true,
      active: true,
  -   notificationsEnabled: true,
  +   pushEnabled: true,
      dailyReminderTime: true,
      weeklyResumeEnabled: true,
      onboardingSeenAt: true,
    } satisfies Prisma.UserSelect;
    
      lastName: user.lastName,
      updatedAt: user.updatedAt,
      avatarKey: user.avatarKey,
      avatarURL: user.avatarURL,
      active: user.active,
  -   notificationsEnabled: user.notificationsEnabled,
  +   pushEnabled: user.pushEnabled,
      dailyReminderTime: user.dailyReminderTime,
      weeklyResumeEnabled: user.weeklyResumeEnabled,
      onboardingSeenAt: user.onboardingSeenAt,
    });
api/src/schemas/user.schema.ts modified+1 -1
api/src/schemas/user.schema.ts
    import { z } from "zod";
    
    export const CreateUserSchema = z.object({
      firstName: z.string(),
      lastName: z.string().optional(),
    
    export type CreateUserInput = z.infer<typeof CreateUserSchema>;
    export type UpdateUserInput = z.infer<typeof UpdateUserSchema>;
    
    export const UpdateUserPreferencesSchema = z.object({
  -   notificationsEnabled: z.boolean().optional(),
  +   pushEnabled: z.boolean().optional(),
      dailyReminderTime: z.string().regex(/^\d{2}:\d{2}$/).nullable().optional(),
      weeklyResumeEnabled: z.boolean().optional(),
    });
    
    export type UpdateUserPreferencesInput = z.infer<typeof UpdateUserPreferencesSchema>;
api/src/services/dailyReminder.sync.ts modified+2 -6
api/src/services/dailyReminder.sync.ts
    import { User } from "@prisma/client";
    import { getQueue } from "@app/lib/queue/QueueRegistry";
    import { DailyReminderJobName } from "@app/lib/queue/types";
    import { logger } from "@app/lib/logger";
    
        if (job.id?.includes(`daily-reminder-user-${user.id}`)) {
          await queue.removeRepeatableByKey(job.key);
        }
      }
    
  -   if (!user.notificationsEnabled || !user.dailyReminderTime) {
  +   if (!user.dailyReminderTime) {
        logger.info(
  -       {
  -         userId: user.id,
  -         enabled: user.notificationsEnabled,
  -         time: user.dailyReminderTime,
  -       },
  +       { userId: user.id, time: user.dailyReminderTime },
          "[daily-sync] user skipped",
        );
    
        return;
      }
      logger.info(
        { userId: user.id, time: user.dailyReminderTime, cron },
        "[daily-sync] scheduled daily reminder",
      );
    }
api/src/services/export/table.descriptors.ts modified+2 -2
api/src/services/export/table.descriptors.ts
    import {
      Activity,
      Appointment,
      CareAction,
      Insight,
        { header: "Nome", value: (user) => user.firstName },
        { header: "Sobrenome", value: (user) => user.lastName },
        { header: "Email", value: (user) => user.email },
        { header: "Ativo", value: (user) => booleanLabel(user.active) },
        {
  -       header: "Notificações",
  -       value: (user) => booleanLabel(user.notificationsEnabled),
  +       header: "Notificações por push",
  +       value: (user) => booleanLabel(user.pushEnabled),
        },
        { header: "Lembrete diário", value: (user) => user.dailyReminderTime },
        {
          header: "Resumo semanal",
          value: (user) => booleanLabel(user.weeklyResumeEnabled),
        { header: "Início do período", value: (insight) => insight.periodStart },
        { header: "Fim do período", value: (insight) => insight.periodEnd },
        { header: "Gerado em", value: (insight) => insight.generatedAt },
      ],
    };
api/src/services/notification.service.ts modified+2 -2
api/src/services/notification.service.ts
    import { Notification, NotificationKind } from "@prisma/client";
    import { endOfDay } from "date-fns";
    
    import { prisma } from "@app/lib/prisma";
    import { APP_TIMEZONE } from "@app/lib/appTime";
    ): Promise<Notification | null> => {
      const { userId, kind, title, body, scheduledFor, regimenId = null } = input;
    
      const user = await prisma.user.findUnique({
        where: { id: userId },
  -     select: { pushToken: true, notificationsEnabled: true },
  +     select: { pushToken: true, pushEnabled: true },
      });
    
      if (!user) {
        logger.warn({ userId, kind }, "[notification] user not found, skipping");
    
          regimenId,
          expiresAt: rule.expiresAt(scheduledFor),
        },
      });
    
  -   if (!user.notificationsEnabled || !user.pushToken) {
  +   if (!user.pushEnabled || !user.pushToken) {
        logger.info(
          { notificationId: notification.id, userId, kind },
          "[notification] stored without push"
        );
    
      return prisma.notification.update({
        where: { id: notification.id },
        data: { pushedAt: new Date() },
      });
    };
api/tests/jobs/export-data.test.ts modified+4 -3
api/tests/jobs/export-data.test.ts
    import { describe, it, expect, afterAll, beforeEach, vi } from 'vitest'
    import JSZip from 'jszip'
    import { exportProcessor } from '@app/lib/queue/processors/exports'
    import { ExportJobName } from '@app/lib/queue/types'
    import { buildPrisma, cleanupTestDb, createTestUser } from '../test-helper'
    
        const lines = csvLines(csv)
        expect(lines).toHaveLength(2)
        expect(lines[0]).toContain('Nome')
        expect(lines[0]).toContain('Email')
  +     expect(lines[0]).toContain('Notificações por push')
    
        const [row] = lines.slice(1)
        expect(row).toContain('"Ana"')
        expect(row).toContain('"Silva"')
        expect(row).toContain('"export@example.com"')
  -     expect(row).toContain('"Sim"') // notifications default to enabled
  +     expect(row).toContain('"Sim"') // push defaults to enabled
        expect(row).toContain('"Não"') // freshly created users are inactive
    
  -     // Secrets must never travel in the export
  +     // Secrets must never travel in the export. The push token is caught by the
  +     // `token` check below; "push" alone is now a legitimate column word.
        const lower = csv.toLowerCase()
        expect(lower).not.toContain('senha')
        expect(lower).not.toContain('token')
  -     expect(lower).not.toContain('push')
        expect(lower).not.toContain('avatar')
    
        const manifest = await zip.file('leia-me.md')!.async('string')
        expect(manifest).toContain('`profile.csv`')
        expect(manifest).toContain('1 registro')
        await expect(
          exportProcessor({ name: 'export:unknown', data: {} } as any)
        ).rejects.toThrow('Unknown export job')
      })
    })
api/tests/jobs/push-notifications.test.ts modified+2 -2
api/tests/jobs/push-notifications.test.ts
    import { describe, it, expect, afterAll, beforeEach, vi } from 'vitest'
    import { medicineReminderProcessor } from '@app/lib/queue/processors/medicineReminders'
    import { dailyReminderProcessor } from '@app/lib/queue/processors/dailyReminders'
    import { buildPrisma, cleanupTestDb, createTestUser } from '../test-helper'
    
    
    describe('dailyReminderProcessor', () => {
      it('stores a daily notification for the reminder time and pushes it', async () => {
        const user = await createTestUser(db, {
          pushToken: 'ExponentPushToken[daily123]',
  -       notificationsEnabled: true,
  +       pushEnabled: true,
        })
    
        await dailyReminderProcessor({
          data: { userId: user.id, scheduledTime: '20:00' },
        } as any)
      })
    
      it('stores the notification without pushing when notifications are disabled', async () => {
        const user = await createTestUser(db, {
          pushToken: 'ExponentPushToken[disabled]',
  -       notificationsEnabled: false,
  +       pushEnabled: false,
        })
    
        await dailyReminderProcessor({
          data: { userId: user.id, scheduledTime: '20:00' },
        } as any)
    
        expect(mockedSend).not.toHaveBeenCalled()
        expect(await db.notification.count()).toBe(0)
      })
    })
api/tests/notifications/create.test.ts modified+4 -4
api/tests/notifications/create.test.ts
    import { describe, it, expect, afterAll, beforeEach, vi } from 'vitest'
    import { NotificationKind } from '@prisma/client'
    import { buildPrisma, cleanupTestDb, createTestUser } from '../test-helper'
    
    vi.mock('@app/lib/sendPushNotification', () => ({
      })
    
      it('records when a push was dispatched', async () => {
        const user = await createTestUser(db, {
          pushToken: 'ExponentPushToken[abc123]',
  -       notificationsEnabled: true,
  +       pushEnabled: true,
        })
    
        await createNotification(dailyInput(user.id))
    
        expect(mockedSend).toHaveBeenCalledOnce()
      })
    
      it('stores the notification but does not push when notifications are disabled', async () => {
        const user = await createTestUser(db, {
          pushToken: 'ExponentPushToken[disabled]',
  -       notificationsEnabled: false,
  +       pushEnabled: false,
        })
    
        await createNotification(dailyInput(user.id))
    
        expect(mockedSend).not.toHaveBeenCalled()
        expect(row).not.toBeNull()
        expect(row?.pushedAt).toBeNull()
      })
    
      it('stores the notification but does not push without a push token', async () => {
  -     const user = await createTestUser(db, { notificationsEnabled: true })
  +     const user = await createTestUser(db, { pushEnabled: true })
    
        await createNotification(dailyInput(user.id))
    
        expect(mockedSend).not.toHaveBeenCalled()
        const row = await db.notification.findFirst()
      })
    
      it('keeps an unpushed record when the push fails', async () => {
        const user = await createTestUser(db, {
          pushToken: 'ExponentPushToken[boom]',
  -       notificationsEnabled: true,
  +       pushEnabled: true,
        })
        mockedSend.mockRejectedValueOnce(new Error('Expo push API returned 500'))
    
        await expect(createNotification(dailyInput(user.id))).resolves.toBeDefined()
    
        expect(result).toBeNull()
        expect(await db.notification.count()).toBe(0)
        expect(mockedSend).not.toHaveBeenCalled()
      })
    })
api/tests/serializers/user.test.ts modified+1 -1
api/tests/serializers/user.test.ts
    import { describe, it, expect } from 'vitest'
    import { User } from '@prisma/client'
    import { publicUser } from '@app/lib/serializers/user'
    
    const row = {
      avatarURL: 'https://cdn.example.com/avatars/pedro.png',
      activationCode: '123456',
      activationCodeExpiresAt: new Date(),
      active: true,
      pushToken: 'device-token',
  -   notificationsEnabled: true,
  +   pushEnabled: true,
      dailyReminderTime: '08:30',
      weeklyResumeEnabled: false,
      onboardingSeenAt: null,
      termsAcceptedAt: new Date(),
      termsVersion: '1',
        ]) {
          expect(safe).not.toHaveProperty(field)
        }
      })
    })
api/tests/test-helper.ts modified+3 -3
api/tests/test-helper.ts
    import { PrismaClient } from '@prisma/client'
    import { PrismaPg } from '@prisma/adapter-pg'
    import jwt from 'jsonwebtoken'
    import bcrypt from 'bcryptjs'
    import { expect } from 'vitest'
        email?: string
        firstName?: string
        lastName?: string
        password?: string
        pushToken?: string
  -     notificationsEnabled?: boolean
  +     pushEnabled?: boolean
      } = {}
    ) {
  -   const { password, pushToken, notificationsEnabled, ...rest } = overrides
  +   const { password, pushToken, pushEnabled, ...rest } = overrides
      return prisma.user.create({
        data: {
          email: rest.email ?? 'test@example.com',
          firstName: rest.firstName ?? 'Test',
          lastName: rest.lastName ?? 'User',
          encryptedPassword: await bcrypt.hash(password ?? 'password123', 10),
          ...(pushToken !== undefined && { pushToken }),
  -       ...(notificationsEnabled !== undefined && { notificationsEnabled }),
  +       ...(pushEnabled !== undefined && { pushEnabled }),
        },
      })
    }
    
    // Fields that must never leave the API. Asserting absence at every
      expect(user).toBeDefined()
      for (const field of SECRET_FIELDS) {
        expect(user).not.toHaveProperty(field)
      }
    }
api/tests/users/preferences.test.ts modified+28 -5
api/tests/users/preferences.test.ts
    import { describe, it, expect, afterAll, beforeEach } from 'vitest'
    import request from 'supertest'
    import { createApp } from '@app/createApp'
    import { DailyReminderJobName } from '@app/lib/queue/types'
    import {
        const token = generateTestToken(user.id, user.email)
    
        const res = await request(app)
          .patch('/users/me')
          .set('Authorization', `Bearer ${token}`)
  -       .send({ user: { notificationsEnabled: true, dailyReminderTime: '08:30' } })
  +       .send({ user: { pushEnabled: true, dailyReminderTime: '08:30' } })
    
        expect(res.status).toBe(200)
  -     expect(res.body.user.notificationsEnabled).toBe(true)
  +     expect(res.body.user.pushEnabled).toBe(true)
        expect(res.body.user.dailyReminderTime).toBe('08:30')
        expectPublicUser(res.body.user)
    
        const dbUser = await db.user.findUnique({ where: { id: user.id } })
        expect(dbUser!.dailyReminderTime).toBe('08:30')
  + 
  +     expect(recordedJobs).toContainEqual(
  +       expect.objectContaining({
  +         queue: 'daily-reminders',
  +         name: DailyReminderJobName.Send,
  +         data: { userId: user.id, scheduledTime: '08:30' },
  +       })
  +     )
  +   })
  + 
  +   it('schedules the daily reminder even when push is disabled', async () => {
  +     const user = await createTestUser(db, {
  +       email: 'nopush@example.com',
  +       pushEnabled: false,
  +     })
  +     const token = generateTestToken(user.id, user.email)
  + 
  +     const res = await request(app)
  +       .patch('/users/me')
  +       .set('Authorization', `Bearer ${token}`)
  +       .send({ user: { dailyReminderTime: '08:30' } })
  + 
  +     expect(res.status).toBe(200)
    
        expect(recordedJobs).toContainEqual(
          expect.objectContaining({
            queue: 'daily-reminders',
            name: DailyReminderJobName.Send,
    
        expect(res.status).toBe(400)
        expect(res.body.fields).toBeTruthy()
      })
    
  -   it('returns 400 for a non-boolean notificationsEnabled', async () => {
  +   it('returns 400 for a non-boolean pushEnabled', async () => {
        const user = await createTestUser(db, { email: 'prefs@example.com' })
        const token = generateTestToken(user.id, user.email)
    
        const res = await request(app)
          .patch('/users/me')
          .set('Authorization', `Bearer ${token}`)
  -       .send({ user: { notificationsEnabled: 'yes' } })
  +       .send({ user: { pushEnabled: 'yes' } })
    
        expect(res.status).toBe(400)
      })
    
      it('returns 401 without a token', async () => {
        const res = await request(app)
          .patch('/users/me')
  -       .send({ user: { notificationsEnabled: false } })
  +       .send({ user: { pushEnabled: false } })
    
        expect(res.status).toBe(401)
      })
    })
frontend/app/(tabs)/settings.tsx modified+70 -9
frontend/app/(tabs)/settings.tsx
    import {
      TouchableOpacity,
      StyleSheet,
      View,
      Switch,
      const [logoutVisible, setLogoutVisible] = useState(false);
      const [exportVisible, setExportVisible] = useState(false);
      const [exporting, setExporting] = useState(false);
      const { showToast } = useToast();
    
  -   const notificationsEnabled = user?.notificationsEnabled ?? true;
  -   const dailyReminderTime = user?.dailyReminderTime ?? "20:00";
  +   const pushEnabled = user?.pushEnabled ?? true;
  +   const dailyReminderTime = user?.dailyReminderTime ?? null;
  +   const reminderEnabled = dailyReminderTime !== null;
      const weeklyResumeEnabled = user?.weeklyResumeEnabled ?? false;
  +   const [lastReminderTime, setLastReminderTime] = useState("20:00");
  +   const reminderTime = dailyReminderTime ?? lastReminderTime;
    
      const patchUserMe = usePatchUserMe((updatedUser) => {
        updateAuthUser(updatedUser);
      });
    
  -   const handleNotificationToggle = (value: boolean) => {
  -     patchUserMe.mutate({ notificationsEnabled: value });
  +   const handlePushToggle = (value: boolean) => {
  +     patchUserMe.mutate({ pushEnabled: value });
  +   };
  + 
  +   const handleReminderToggle = (value: boolean) => {
  +     if (dailyReminderTime) {
  +       setLastReminderTime(dailyReminderTime);
  +     }
  + 
  +     patchUserMe.mutate({ dailyReminderTime: value ? reminderTime : null });
      };
    
      const handleWeeklyResumeToggle = (value: boolean) => {
        patchUserMe.mutate({ weeklyResumeEnabled: value });
      };
    
      const handleTimeChange = (date: Date) => {
        const time = `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
  +     setLastReminderTime(time);
        patchUserMe.mutate({ dailyReminderTime: time });
      };
    
      const textColor = useThemeColor({}, "text");
    
                    justifyContent: "space-between",
                    marginLeft: 12,
                    flex: 1,
                  }}
                >
  +               <Text style={styles.rowLabel}>Notificações por push</Text>
  +               <Text style={styles.rowSubtitle}>
  +                 Os lembretes continuam no app mesmo com o push desativado.
  +               </Text>
  +             </View>
  + 
  +             <Switch
  +               onValueChange={handlePushToggle}
  +               thumbColor={Colors.light.tint}
  +               trackColor={{
  +                 false: Colors.light.disabled,
  +                 true: Colors.light.gray,
  +               }}
  +               value={pushEnabled}
  +               disabled={patchUserMe.isPending}
  +             />
  +           </View>
  + 
  +           <View style={styles.divider} />
  + 
  +           <View
  +             style={{
  +               flexDirection: "row",
  +               alignItems: "center",
  +               justifyContent: "space-between",
  +             }}
  +           >
  +             <View
  +               style={[
  +                 styles.cardIcon,
  +                 { backgroundColor: Colors.light.accentIndigo, marginBottom: 5 },
  +               ]}
  +             >
  +               <Ionicons
  +                 name="alarm-outline"
  +                 size={20}
  +                 color={Colors.light.black}
  +               />
  +             </View>
  + 
  +             <View
  +               style={{
  +                 flexDirection: "column",
  +                 alignItems: "flex-start",
  +                 justifyContent: "space-between",
  +                 marginLeft: 12,
  +                 flex: 1,
  +               }}
  +             >
                  <Text style={styles.rowLabel}>Lembrete diário de humor</Text>
                  <Text style={styles.rowSubtitle}>
  -                 {notificationsEnabled ? `Diário às ${dailyReminderTime}` : "Desativado"}
  +                 {reminderEnabled ? `Diário às ${reminderTime}` : "Desativado"}
                  </Text>
                </View>
    
                <Switch
  -               onValueChange={handleNotificationToggle}
  +               onValueChange={handleReminderToggle}
                  thumbColor={Colors.light.tint}
                  trackColor={{
                    false: Colors.light.disabled,
                    true: Colors.light.gray,
                  }}
  -               value={notificationsEnabled}
  +               value={reminderEnabled}
                  disabled={patchUserMe.isPending}
                />
              </View>
    
  -           {notificationsEnabled && (
  +           {reminderEnabled && (
                <TimePicker
                  value={(() => {
  -                 const [h, m] = dailyReminderTime.split(":").map(Number);
  +                 const [h, m] = reminderTime.split(":").map(Number);
                    const d = new Date();
                    d.setHours(h, m, 0, 0);
                    return d;
                  })()}
                  onChange={handleTimeChange}
        height: StyleSheet.hairlineWidth,
        backgroundColor: "#D1D5DB",
        marginVertical: 16,
      },
    });
frontend/lib/api/types.ts modified+2 -2
frontend/lib/api/types.ts
    export interface User {
      id: number;
      email: string;
      firstName: string;
      lastName?: string;
      updatedAt: Date;
      avatarKey?: string;
      avatarURL?: string;
      active: boolean;
  -   notificationsEnabled?: boolean;
  +   pushEnabled?: boolean;
      dailyReminderTime?: string;
      weeklyResumeEnabled?: boolean;
      onboardingSeenAt?: Date | null;
    }
    
    export interface UserUpdateResponse {
      user: User;
    }
    
    export interface UserPreferencesPayload {
  -   notificationsEnabled?: boolean;
  +   pushEnabled?: boolean;
      dailyReminderTime?: string | null;
      weeklyResumeEnabled?: boolean;
    }
    
    export interface ExportDataResponse {
      moodId?: number;
    }
    export interface MedicineRegimenResponse { regimen: MedicineRegimen; }
    
    export interface LinkMoodPayload { moodId: number; perceivedImpact: number; }