api: store/fetch triggers

Pedro Lucas Porcellis porcellis@eletrotupi.com 14 days ago 92fcd2f123abee1a1608f8f79f17fc9ca250e673

Parents: 4ef759a

8 file(s) changed

api/prisma/migrations/20260604225204_rename_triggers_enums/migration.sql +14 -0
api/prisma/schema.prisma +3 -2
api/src/controllers/triggers.ts +58 -0
api/src/createApp.ts +2 -0
api/src/routes/triggers.ts +11 -0
api/src/schemas/index.ts +5 -0
api/src/schemas/trigger.schema.ts +12 -0
api/src/services/trigger.service.ts +69 -0

api/prisma/migrations/20260604225204_rename_triggers_enums/migration.sql

@@ -0,0 +1,14 @@
  + /*
  +   Warnings:
  + 
  +   - The values [ENVIRONMENTAL,EMOTIONAL] on the enum `TriggerType` will be removed. If these variants are still used in the database, this will fail.
  + 
  + */
  + -- AlterEnum
  + BEGIN;
  + CREATE TYPE "TriggerType_new" AS ENUM ('SOCIAL', 'WORK', 'HEALTH', 'PHYSICAL', 'FAMILY', 'OTHER');
  + ALTER TABLE "triggers" ALTER COLUMN "category" TYPE "TriggerType_new" USING ("category"::text::"TriggerType_new");
  + ALTER TYPE "TriggerType" RENAME TO "TriggerType_old";
  + ALTER TYPE "TriggerType_new" RENAME TO "TriggerType";
  + DROP TYPE "public"."TriggerType_old";
  + COMMIT;

api/prisma/schema.prisma

@@ -127,9 +127,10 @@ }
    
    enum TriggerType {
      SOCIAL
  -   ENVIRONMENTAL
  -   EMOTIONAL
  +   WORK
  +   HEALTH
      PHYSICAL
  +   FAMILY
      OTHER
    }
    

api/src/controllers/triggers.ts

@@ -0,0 +1,58 @@
  + import { Request, Response, NextFunction } from 'express';
  + import { AuthenticatedRequest } from '@app/middleware/auth';
  + import {
  +   createTrigger,
  +   getTriggersByUserId,
  +   destroyTriggerById
  + } from '@app/services/trigger.service';
  + 
  + import {
  +   CreateTriggerSchema
  + } from '@app/schemas'
  + 
  + export const TriggersController = {
  +   create: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = CreateTriggerSchema.safeParse(req.body.trigger);
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({
  +           errors: parsed.error!.issues
  +         });
  +       }
  + 
  +       const trigger = await createTrigger(req.userId!, parsed.data);
  + 
  +       return res.status(201).json({ trigger });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   index: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const result = await getTriggersByUserId(Number(req.userId), {
  +         limit: req.query.limit ? Number(req.query.limit) : undefined,
  +         page:  req.query.page  ? Number(req.query.page)  : undefined,
  +         from:  req.query.from  as string | undefined,
  +         to:    req.query.to    as string | undefined,
  +       });
  + 
  +       return res.status(200).json(
  +         result
  +       )
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   destroy: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const result = await destroyTriggerById(req.userId!, Number(req.params.id!));
  + 
  +       return res.status(200).json({})
  +     } catch (err) {
  +       next(err);
  +     }
  +   }
  + };

api/src/createApp.ts

@@ -6,6 +6,7 @@ import mainRouter from '@app/routes/main';
    import userRouter from '@app/routes/users';
    import authRouter from '@app/routes/auth';
    import moodRouter from '@app/routes/moods';
  + import triggerRouter from '@app/routes/triggers';
    import sleepRecordRouter from '@app/routes/sleepRecords';
    import { errorHandler } from '@app/middleware/errorHandler';
    import { PrismaClient } from '@prisma/client';

@@ -46,6 +47,7 @@ app.use("/users", userRouter);
      app.use("/auth", authRouter);
      app.use("/moods", moodRouter);
      app.use("/sleep_records", sleepRecordRouter);
  +   app.use("/triggers", triggerRouter);
    
      app.use(errorHandler); // always last
    

api/src/routes/triggers.ts

@@ -0,0 +1,11 @@
  + import { Router } from "express";
  + import { TriggersController } from '@app/controllers/triggers'
  + import { requireAuth } from '@app/middleware/auth';
  + 
  + const router = Router();
  + 
  + router.get('/', requireAuth, TriggersController.index);
  + router.post('/', requireAuth, TriggersController.create);
  + router.delete('/:id', requireAuth, TriggersController.destroy);
  + 
  + export default router;

api/src/schemas/index.ts

@@ -29,3 +29,8 @@ export {
      type CreateSleepRecordInput,
      CreateSleepRecordSchema
    } from '@app/schemas/sleepRecord.schema';
  + 
  + export {
  +   type CreateTriggerInput,
  +   CreateTriggerSchema
  + } from '@app/schemas/trigger.schema';

api/src/schemas/trigger.schema.ts

@@ -0,0 +1,12 @@
  + import { z } from 'zod';
  + import {
  +   TriggerType
  + } from '@prisma/client';
  + 
  + export const CreateTriggerSchema = z.object({
  +   comment: z.string().optional(),
  +   moment: z.coerce.date(),
  +   category: z.nativeEnum(TriggerType)
  + });
  + 
  + export type CreateTriggerInput = z.infer<typeof CreateTriggerSchema>;

api/src/services/trigger.service.ts

@@ -0,0 +1,69 @@
  + import { prisma } from '@app/lib/prisma';
  + import { Trigger } from '@prisma/client';
  + 
  + import { CreateTriggerInput } from '@app/schemas';
  + 
  + export const createTrigger = async (
  +   userId: number, input: CreateTriggerInput
  + ): Promise<Trigger> => {
  +   return prisma.trigger.create({
  +     data: {
  +       ...input,
  +       userId
  +     }
  +   });
  + };
  + 
  + export const getTriggersByUserId = async (
  +   userId: number,
  +   params?: {
  +     limit?: number;
  +     page?: number;
  +     from?: string;
  +     to?: string;
  +   }
  + ): Promise<{ entries: Trigger[]; total: number; page: number; nextPage: number | null }> => {
  +   const page  = params?.page  ?? 1;
  +   const limit = params?.limit ?? 20;
  +   const skip  = (page - 1) * limit;
  + 
  +   const where = {
  +     userId,
  +     ...(params?.from || params?.to ? {
  +       moment: {
  +         ...(params.from && { gte: new Date(params.from) }),
  +         ...(params.to   && { lte: new Date(params.to)   }),
  +       }
  +     } : {}),
  +   };
  + 
  +   const [entries, total] = await Promise.all([
  +     prisma.trigger.findMany({
  +       where,
  +       orderBy: { moment: 'desc' },
  +       take: limit,
  +       skip,
  +     }),
  +     prisma.trigger.count({ where }),
  +   ]);
  + 
  +   const totalPages = Math.ceil(total / limit);
  + 
  +   return {
  +     entries,
  +     total,
  +     page,
  +     nextPage: page < totalPages ? page + 1 : null,
  +   };
  + };
  + 
  + export const destroyTriggerById = async (
  +   userId: number, id: number
  + ): Promise<Trigger> => {
  +   return await prisma.trigger.delete({
  +     where: {
  +       id,
  +       userId
  +     }
  +   })
  + }