generator client {

  provider = "prisma-client-js"

  //output   = "../src/generated/prisma"

}

  active                  Boolean   @default(false) @map("active")

  pushToken            String?  @map("push_token")

  notificationsEnabled Boolean  @default(true) @map("notifications_enabled")

  dailyReminderTime    String?  @map("daily_reminder_time")

  onboardingSeenAt DateTime? @map("onboarding_seen_at")

  termsAcceptedAt  DateTime? @map("terms_accepted_at")

  termsVersion     String?   @map("terms_version")

  THREE_TIMES_DAILY

  WEEKLY

  BIWEEKLY

  MONTHLY

}

import { Prisma, User } from '@prisma/client';

// DB-level projection of the allow-list below — keep the two in sync.

export const publicUserSelect = {

  id: true,

  avatarKey: true,

  avatarURL: true,

  active: true,

  notificationsEnabled: true,

  dailyReminderTime: true,

  onboardingSeenAt: true,

} satisfies Prisma.UserSelect;

// The only shape a user leaves the API in. Everything not listed here

// (encryptedPassword, reset secrets, activation code, pushToken) stays server-side.

  avatarKey: user.avatarKey,

  avatarURL: user.avatarURL,

  active: user.active,

  notificationsEnabled: user.notificationsEnabled,

  dailyReminderTime: user.dailyReminderTime,

  onboardingSeenAt: user.onboardingSeenAt,

});

import { z } from "zod";

export const CreateUserSchema = z.object({

  firstName: z.string(),

  lastName: z.string().optional(),

export type UpdateUserInput = z.infer<typeof UpdateUserSchema>;

export const UpdateUserPreferencesSchema = z.object({

  notificationsEnabled: z.boolean().optional(),

  dailyReminderTime: z.string().regex(/^\d{2}:\d{2}$/).nullable().optional(),

});

export type UpdateUserPreferencesInput = z.infer<typeof UpdateUserPreferencesSchema>;

import {

  Activity,

  Appointment,

  CareAction,

  Insight,

    {

      header: "Notificações",

      value: (user) => booleanLabel(user.notificationsEnabled),

    },

    { header: "Lembrete diário", value: (user) => user.dailyReminderTime },

    { header: "Criado em", value: (user) => user.createdAt },

    { header: "Atualizado em", value: (user) => user.updatedAt },

  ],

};

    { 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 },

  ],

};

import { describe, it, expect } from 'vitest'

import { User } from '@prisma/client'

import { publicUser } from '@app/lib/serializers/user'

const row = {

  activationCodeExpiresAt: new Date(),

  active: true,

  pushToken: 'device-token',

  notificationsEnabled: true,

  dailyReminderTime: '08:30',

  onboardingSeenAt: null,

  termsAcceptedAt: new Date(),

  termsVersion: '1',

} as User

    expect(publicUser(row)).toMatchObject({

      id: 7,

      email: 'pedro@example.com',

      firstName: 'Pedro',

      active: true,

      onboardingSeenAt: null,

    })

  })

  it('never carries a secret off the server', () => {

    ]) {

      expect(safe).not.toHaveProperty(field)

    }

  })

})

import { describe, it, expect, afterAll, beforeEach } from 'vitest'

import request from 'supertest'

import { createApp } from '@app/createApp'

import { buildPrisma, cleanupTestDb, createTestUser, generateTestToken, expectPublicUser } from '../test-helper'

      .set('Authorization', `Bearer ${token}`)

    expect(res.status).toBe(200)

    expect(res.body.user.email).toBe('me@example.com')

    expect(res.body.user.firstName).toBe('Pedro')

    expectPublicUser(res.body.user)

  })

  it('returns 401 without token', async () => {

    const res = await request(app).get('/users/me')

    expect(res.status).toBe(401)

  })

})

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 {

        data: { userId: user.id },

      })

    )

  })

  it('accepts a null reminder time and schedules nothing', async () => {

    const user = await createTestUser(db, { email: 'prefs@example.com' })

    const token = generateTestToken(user.id, user.email)

    const res = await request(app)

      .send({ user: { notificationsEnabled: false } })

    expect(res.status).toBe(401)

  })

})

import { ScreenLayout } from "@/components/ui/ScreenLayout";

import { useAuth } from "@/context/AuthContext";

import { Section, SectionHeader } from "@/components/ui/Sections";

import { WeeklyResume } from "@/components/insights/WeeklyResume";

import { MoodTrendWidget } from "@/components/insights/MoodTrendWidget";

    <ScreenLayout

      userName={user?.firstName}

      userAvatar={user?.avatarURL}

      showNotificationBadge={true}

    >

      <Section>

        <SectionHeader title="Indicadores" subtitle="Baseado nos últimos 7 dias" />

        <EnergySleepWidget />

        <TriggerPatternWidget />

      </Section>

    </ScreenLayout>

  );

}

import {

  TouchableOpacity,

  StyleSheet,

  View,

  Switch,

import { useToast } from '@/context/ToastContext';

import { apiClient } from "@/lib/api";

export default function Settings() {

  const { user, logout, updateAuthUser } = useAuth();

  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 patchUserMe = usePatchUserMe((updatedUser) => {

    updateAuthUser(updatedUser);

  });

  const handleNotificationToggle = (value: boolean) => {

    patchUserMe.mutate({ notificationsEnabled: value });

  };

  const handleTimeChange = (date: Date) => {

    const time = `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;

    patchUserMe.mutate({ dailyReminderTime: time });

                justifyContent: "space-between",

                marginLeft: 12,

                flex: 1,

              }}

            >

            </View>

            <Switch

              thumbColor={Colors.light.tint}

              trackColor={{

                false: Colors.light.disabled,

                true: Colors.light.gray,

              }}

            />

          </View>

        </Card>

      </Section>

    height: StyleSheet.hairlineWidth,

    backgroundColor: "#D1D5DB",

    marginVertical: 16,

  },

});

export interface User {

  id: number;

  email: string;

  firstName: string;

  lastName?: string;

  avatarKey?: string;

  avatarURL?: string;

  active: boolean;

  notificationsEnabled?: boolean;

  dailyReminderTime?: string;

  onboardingSeenAt?: Date | null;

}

export interface AvatarResponse {

  message: string;

}

export interface UserPreferencesPayload {

  notificationsEnabled?: boolean;

  dailyReminderTime?: string | null;

}

export interface ExportDataResponse {

  message: string;

}

  moodId?: number;

}

export interface MedicineRegimenResponse { regimen: MedicineRegimen; }

export interface LinkMoodPayload { moodId: number; perceivedImpact: number; }