api: add a controller for fetching insights

Pedro Lucas Porcellis porcellis@eletrotupi.com 4 days ago b3cae39fbd7a790d651c1950d4bc42dc3bc9e9aa

Parents: a772f94

6 file(s) changed

api/src/controllers/insights.ts +33 -0
api/src/createApp.ts +16 -12
api/src/routes/insights.ts +9 -0
api/src/schemas/index.ts +15 -12
api/src/schemas/insight.schema.ts +10 -0
api/src/services/insight.service.ts +31 -0

api/src/controllers/insights.ts

@@ -0,0 +1,33 @@
  + import { Response, NextFunction } from "express";
  + import { AuthenticatedRequest } from "@app/middleware/auth";
  + import { getInsightsByUserId } from "@app/services/insight.service";
  + import { InsightsQuerySchema } from "@app/schemas";
  + 
  + export const InsightsController = {
  +   index: async (
  +     req: AuthenticatedRequest,
  +     res: Response,
  +     next: NextFunction,
  +   ) => {
  +     try {
  +       const parsedQuery = InsightsQuerySchema.safeParse(req.query);
  + 
  +       if (!parsedQuery.success) {
  +         return res.status(400).json({
  +           message: "Invalid query parameters",
  +           errors: parsedQuery.error.flatten(),
  +         });
  +       }
  + 
  +       const insights = await getInsightsByUserId(req.userId!, {
  +         type: parsedQuery.data.type,
  +         period: parsedQuery.data.period,
  +         limit: parsedQuery.data.limit,
  +       });
  + 
  +       return res.status(200).json({ insights });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + };

api/src/createApp.ts

@@ -28,24 +28,26 @@ bootWorkers();
      scheduleInsights();
    
      // Configure CORS
  -   app.use(cors({
  -     origin: process.env.FRONTEND_URL || '*',
  -     credentials: true
  -   }));
  +   app.use(
  +     cors({
  +       origin: process.env.FRONTEND_URL || "*",
  +       credentials: true,
  +     }),
  +   );
    
      app.use(bodyParser.json());
    
  -   const isDev = process.env.NODE_ENV !== 'production';
  +   const isDev = process.env.NODE_ENV !== "production";
    
      const logger = pino({
  -     level: process.env.LOG_LEVEL || 'info',
  +     level: process.env.LOG_LEVEL || "info",
        ...(isDev && {
          transport: {
  -         target: 'pino-pretty',
  +         target: "pino-pretty",
            options: {
              colorize: true,
              singleLine: false,
  -           messageFormat: '{if levelLabel}{levelLabel} - {end}{msg}',
  +           messageFormat: "{if levelLabel}{levelLabel} - {end}{msg}",
            },
          },
        }),

@@ -59,16 +61,18 @@ app.use("/auth", authRouter);
      app.use("/moods", moodRouter);
      app.use("/sleep_records", sleepRecordRouter);
      app.use("/triggers", triggerRouter);
  +   app.use("/insights", insightRouter);
    
      app.use(errorHandler); // always last
    
      // TODO: flesh the actual page here
  -   app.use(express.static(path.join(__dirname, './static')));
  +   app.use(express.static(path.join(__dirname, "./static")));
      app.get(/.*/, (req, res) => {
  -     res.sendFile(path.join(__dirname, './static/index.html')); });
  +     res.sendFile(path.join(__dirname, "./static/index.html"));
  +   });
    
  -   process.on('SIGTERM', shutdown);
  -   process.on('SIGINT', shutdown);
  +   process.on("SIGTERM", shutdown);
  +   process.on("SIGINT", shutdown);
    
      return app;
    }

api/src/routes/insights.ts

@@ -0,0 +1,9 @@
  + import { Router } from "express";
  + import { requireAuth } from "@app/middleware/auth";
  + import { InsightsController } from "@app/controllers/insights";
  + 
  + const router = Router();
  + 
  + router.get("/", requireAuth, InsightsController.index);
  + 
  + export default router;

api/src/schemas/index.ts

@@ -1,18 +1,16 @@
    export {
      CreateMoodSchema,
  -   MoodComponentSchema
  - } from '@app/schemas/mood.schema';
  +   MoodComponentSchema,
  + } from "@app/schemas/mood.schema";
    
  - export type {
  -   CreateMoodInput
  - } from '@app/schemas/mood.schema';
  + export type { CreateMoodInput } from "@app/schemas/mood.schema";
    
    export {
      CreateUserSchema,
      UpdateUserSchema,
      type CreateUserInput,
      type UpdateUserInput,
  - } from '@app/schemas/user.schema';
  + } from "@app/schemas/user.schema";
    
    export {
      LoginSchema,

@@ -22,15 +20,20 @@ ActivateUserSchema,
      type LoginInput,
      type PasswordResetRequestInput,
      type PasswordResetInput,
  -   type ActivateUserInput
  - } from '@app/schemas/auth.schema';
  +   type ActivateUserInput,
  + } from "@app/schemas/auth.schema";
    
    export {
      type CreateSleepRecordInput,
  -   CreateSleepRecordSchema
  - } from '@app/schemas/sleepRecord.schema';
  +   CreateSleepRecordSchema,
  + } from "@app/schemas/sleepRecord.schema";
    
    export {
      type CreateTriggerInput,
  -   CreateTriggerSchema
  - } from '@app/schemas/trigger.schema';
  +   CreateTriggerSchema,
  + } from "@app/schemas/trigger.schema";
  + 
  + export {
  +   InsightsQuerySchema,
  +   type InsightsQueryInput,
  + } from "@app/schemas/insight.schema";

api/src/schemas/insight.schema.ts

@@ -0,0 +1,10 @@
  + import { z } from 'zod';
  + import { InsightPeriod, InsightType } from '@prisma/client';
  + 
  + export const InsightsQuerySchema = z.object({
  +   type: z.nativeEnum(InsightType).optional(),
  +   period: z.nativeEnum(InsightPeriod).optional(),
  +   limit: z.coerce.number().int().positive().max(100).optional(),
  + });
  + 
  + export type InsightsQueryInput = z.infer<typeof InsightsQuerySchema>;

api/src/services/insight.service.ts

@@ -0,0 +1,31 @@
  + import { prisma } from "@app/lib/prisma";
  + import { Insight, InsightType, InsightPeriod } from "@prisma/client";
  + 
  + export const getInsightsByUserId = async (
  +   userId: number,
  +   params?: {
  +     type?: InsightType;
  +     period?: InsightPeriod;
  +     limit?: number;
  +   },
  + ): Promise<Insight[]> => {
  +   return prisma.insight.findMany({
  +     where: {
  +       userId,
  +       ...(params?.type && { type: params.type }),
  +       ...(params?.period && { period: params.period }),
  +     },
  +     orderBy: { generatedAt: "desc" },
  +     take: params?.limit ?? 10,
  +   });
  + };
  + 
  + export const getLatestInsightByType = async (
  +   userId: number,
  +   type: InsightType,
  + ): Promise<Insight | null> => {
  +   return prisma.insight.findFirst({
  +     where: { userId, type },
  +     orderBy: { generatedAt: "desc" },
  +   });
  + };