eletrotupi/tcc — frontend/insights: the daily pair reads today's insight • pira

eletrotupi / tcc/ commit / 8873ae7

frontend/insights: the daily pair reads today's insight

The insight hook now returns metadata typed for the type requested, so
the energy and sleep cards read their comparison and window fields with
no cast. The cache key picks up the device's local date, so the pair
refetches after midnight rather than keeping yesterday's row

Pedro Lucas Porcellis porcellis@eletrotupi.com · 12 days ago 8873ae72bb5c5381f95356155b0c0cb1d4041156 Browse files

Parents b36ca93

Changed files

Additions

+66

Deletions

-61

frontend/components/ui/DailyEnergyWidget.tsx modified+4 -9
frontend/components/ui/DailyEnergyWidget.tsx
    import { ActivityIndicator, StyleSheet, View } from "react-native";
    import { Text } from "@/components/ui/Text";
    import { Card } from "@/components/ui/Cards";
    import { useInsight } from "@/hooks/useInsights.queries";
    import { Ionicons } from "@expo/vector-icons";
    import { Typography, Spacing, Colors, BorderRadius } from "@/constants/theme";
    
    export const DailyEnergyWidget = () => {
      const { data: insight, isLoading } = useInsight("DAILY_ENERGY");
    
  -   const metadata = insight?.metadata as {
  -     peak: number;
  -     trough: number;
  -     entryCount: number;
  -     avgEnergy: number;
  -   };
  +   const metadata = insight?.metadata;
    
  -   const avgEnergy = metadata?.avgEnergy;
  -   const peak = metadata?.peak;
  +   const avgEnergy = metadata?.avgEnergy ?? 0;
  +   const peak = metadata?.peak ?? 0;
    
  -   const energyWidth = (avgEnergy / peak) * 100;
  +   const energyWidth = peak > 0 ? (avgEnergy / peak) * 100 : 0;
      const energySummary = () => {
        if (avgEnergy < 3) return "Energia baixa";
        if (avgEnergy < 5) return "Media baixa";
        if (avgEnergy < 7.5) return "Média Alta";
        return "Energia alta";
        fontSize: 11,
        fontWeight: 600,
        lineHeight: 16.5,
      },
    });
frontend/components/ui/DailySleepWidget.tsx modified+1 -6
frontend/components/ui/DailySleepWidget.tsx
    import React from "react";
    import { View, StyleSheet, ActivityIndicator } from "react-native";
    import { Text } from "@/components/ui/Text";
    import { Card } from "./Cards";
    import { Colors, Spacing, Typography } from "@/constants/theme";
    import { useInsight } from "@/hooks/useInsights.queries";
    
    export const DailySleepWidget = () => {
      const { data: insight, isLoading } = useInsight("DAILY_SLEEP");
    
  -   const metadata = insight?.metadata as
  -     | {
  -         diffStr: string;
  -         diffMinutes: number;
  -       }
  -     | undefined;
  +   const metadata = insight?.metadata;
    
      const diffColor = metadata?.diffMinutes
        ? metadata.diffMinutes < 0
          ? Colors.light.danger
          : Colors.light.tint
      empty: {
        ...Typography.labelSm,
        opacity: 0.5,
      },
    });
frontend/hooks/useInsights.queries.ts modified+11 -3
frontend/hooks/useInsights.queries.ts
  + import { format } from "date-fns";
    import { useQuery } from "@tanstack/react-query";
    import { apiClient, Insight, InsightType, InsightPeriod } from "@/lib/api";
  + 
  + // The device's local calendar day, used only to roll the cache over at midnight
  + // so the pair refetches; the server still resolves the actual day boundary
  + function localDay(): string {
  +   return format(new Date(), "yyyy-MM-dd");
  + }
    
    export const insightKeys = {
      all: () => ["insights"] as const,
      lists: () => [...insightKeys.all(), "list"] as const,
      list: (filters?: InsightFilters) =>
        [...insightKeys.lists(), filters] as const,
  -   byType: (type: InsightType) => [...insightKeys.all(), "type", type] as const,
  +   byType: (type: InsightType) =>
  +     [...insightKeys.all(), "type", type, localDay()] as const,
    };
    
    interface InsightFilters {
      type?: InsightType;
      period?: InsightPeriod;
      ENERGY_SLEEP_CORRELATION: "WEEKLY",
      TRIGGER_PATTERN: "WEEKLY",
      DAILY_SLEEP: "DAILY",
    };
    
  - export const useInsight = (type: InsightType) => {
  + export const useInsight = <T extends InsightType>(type: T) => {
      const period = INSIGHT_PERIOD[type];
      const staleTime = INSIGHT_STALE_TIMES[period];
    
      return useQuery({
        queryKey: insightKeys.byType(type),
        queryFn: () =>
          apiClient
  -         .getInsights({ type, limit: 1 })
  +         .getInsights<T>({ type, limit: 1 })
            .then((res) => res.insights[0] ?? null),
        staleTime,
      });
    };
    
        queryKey: insightKeys.list(filters),
        queryFn: () => apiClient.getInsights(filters).then((res) => res.insights),
        staleTime: 1000 * 60 * 15,
      });
    };
frontend/lib/api/client.ts modified+6 -4
frontend/lib/api/client.ts
    import * as SecureStore from "expo-secure-store";
    import Constants from "expo-constants";
    
    export class ApiError extends Error {
      status: number;
      async deleteTrigger(id: string): Promise<void> {
        return this.request(`/triggers/${id}`, { method: "DELETE" });
      }
    
      // Insights
  -   async getInsights(filters?: {
  -     type?: InsightType;
  +   async getInsights<T extends InsightType = InsightType>(filters?: {
  +     type?: T;
        period?: InsightPeriod;
        limit?: number;
  -   }): Promise<{ insights: Insight[] }> {
  +   }): Promise<{ insights: Insight<T>[] }> {
        const query = new URLSearchParams();
        if (filters?.type) query.set("type", filters.type);
        if (filters?.period) query.set("period", filters.period);
        if (filters?.limit) query.set("limit", String(filters.limit));
    
        const qs = query.toString();
  -     return this.request(`/insights${qs ? `?${qs}` : ""}`);
  +     return this.request<{ insights: Insight<T>[] }>(
  +       `/insights${qs ? `?${qs}` : ""}`,
  +     );
      }
    
      // Medicine Regimens
      async getMedicineRegimens(): Promise<{ regimens: MedicineRegimen[] }> {
        return this.request('/medicine-regimens');
        return response.arrayBuffer()
      }
    }
    
    export const apiClient = new ApiClient();
frontend/lib/api/types.ts modified+44 -39
frontend/lib/api/types.ts
    export interface User {
      id: number;
      email: string;
      firstName: string;
      lastName?: string;
      | "DAILY_ENERGY"
      | "DAILY_SLEEP";
    
    export type InsightPeriod = "DAILY" | "WEEKLY" | "MONTHLY";
    
  - export type InsightMetadata =
  -   | {
  -       type: "MOOD_TREND";
  -       delta: number;
  -       avgFirst: number;
  -       avgSecond: number;
  -       dominantMood: string;
  -       avgEnergy: number;
  -     }
  -   | {
  -       type: "ENERGY_SLEEP_CORRELATION";
  -       correlationScore: number;
  -       sampleSize: number;
  -     }
  -   | {
  -       type: "TRIGGER_PATTERN";
  -       topCategory: string;
  -       topCount: number;
  -       total: number;
  -       distribution: Record<string, number>;
  -     }
  -   | {
  -       type: "DAILY_ENERGY";
  -       avgEnergy: number;
  -       dayTrend: number | null;
  -       peak: number;
  -       trough: number;
  -       entryCount: number;
  -     }
  -   | {
  -       type: "DAILY_SLEEP";
  -       totalHours: number;
  -       diffMinutes: number;
  -       sessionCount: number;
  -       hadNaps: boolean;
  -     };
  + export interface InsightMetadataByType {
  +   MOOD_TREND: {
  +     delta: number;
  +     avgFirst: number;
  +     avgSecond: number;
  +     dominantMood: string;
  +     avgEnergy: number;
  +   };
  +   ENERGY_SLEEP_CORRELATION: {
  +     correlationScore: number;
  +     sampleSize: number;
  +   };
  +   TRIGGER_PATTERN: {
  +     topCategory: string;
  +     topCount: number;
  +     total: number;
  +     distribution: Record<string, number>;
  +   };
  +   DAILY_ENERGY: {
  +     avgEnergy: number;
  +     dayTrend: number | null;
  +     peak: number;
  +     trough: number;
  +     entryCount: number;
  +     yesterdayAvg: number | null;
  +     diffEnergy: number | null;
  +     windowLabel: string;
  +   };
  +   DAILY_SLEEP: {
  +     totalHours: number;
  +     diffMinutes: number | null;
  +     diffStr: string;
  +     sessionCount: number;
  +     napStr: string;
  +     hadNaps: boolean;
  +     windowLabel: string;
  +   };
  + }
  + 
  + export type InsightMetadata<T extends InsightType = InsightType> =
  +   InsightMetadataByType[T];
    
  - export type Insight = {
  + export type Insight<T extends InsightType = InsightType> = {
      id: number;
  -   type: InsightType;
  +   type: T;
      period: InsightPeriod;
      title: string;
      body: string;
  -   metadata: InsightMetadata;
  +   metadata: InsightMetadata<T>;
      generatedAt: string;
      periodStart: string;
      periodEnd: string;
    };
    
      moodId?: number;
    }
    export interface MedicineRegimenResponse { regimen: MedicineRegimen; }
    
    export interface LinkMoodPayload { moodId: number; perceivedImpact: number; }