api: flesh sleep records endpoints

Pedro Lucas Porcellis porcellis@eletrotupi.com 25 days ago 04f35e5e8f22150925526590ee8626257701a10b

Parents: 4ead651

7 file(s) changed

api/src/controllers/main.ts +1 -1
api/src/controllers/sleepRecords.ts +58 -0
api/src/createApp.ts +8 -1
api/src/routes/sleepRecords.ts +11 -0
api/src/schemas/index.ts +5 -0
api/src/schemas/sleepRecord.schema.ts +9 -0
api/src/services/sleepRecord.service.ts +69 -0

api/src/controllers/main.ts

@@ -5,7 +5,7 @@ // TODO: replace with a HTML response for the main app
      index: async (req: Request, res: Response, next: NextFunction) => {
        try {
          const { message } = req.params;
  -       res.json({ status: 'alive' });
  +       res.send('../static/index.html');
        } catch (err) {
          next(err);
        }

api/src/controllers/sleepRecords.ts

@@ -0,0 +1,58 @@
  + import { Request, Response, NextFunction } from 'express';
  + import { AuthenticatedRequest } from '@app/middleware/auth';
  + import {
  +   createSleepRecord,
  +   getSleepRecordsByUserId,
  +   destroySleepRecordById
  + } from '@app/services/sleepRecord.service';
  + 
  + import {
  +   CreateSleepRecordSchema
  + } from '@app/schemas'
  + 
  + export const SleepRecordsController = {
  +   create: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const parsed = CreateSleepRecordSchema.safeParse(req.body.sleepRecord);
  + 
  +       if (!parsed.success) {
  +         return res.status(400).json({
  +           errors: parsed.error!.issues
  +         });
  +       }
  + 
  +       const sleepRecord = await createSleepRecord(req.userId!, parsed.data);
  + 
  +       return res.status(201).json({ sleepRecord });
  +     } catch (err) {
  +       next(err);
  +     }
  +   },
  + 
  +   index: async (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
  +     try {
  +       const result = await getSleepRecordsByUserId(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 destroySleepRecordById(req.userId!, Number(req.params.id!));
  + 
  +       return res.status(200).json({})
  +     } catch (err) {
  +       next(err);
  +     }
  +   }
  + };

api/src/createApp.ts

@@ -6,11 +6,13 @@ 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 sleepRecordRouter from '@app/routes/sleepRecords';
    import { errorHandler } from '@app/middleware/errorHandler';
    import { PrismaClient } from '@prisma/client';
    import { bootWorkers, closeAllWorkers, closeAllQueues } from '@app/lib/queue';
    import pino from 'pino';
    import pinoHttp from 'pino-http';
  + import path from 'path';
    
    export function createApp() {
      const app = express();

@@ -40,12 +42,17 @@
      // Use pino-http for HTTP logging (better than Morgan for structured logs)
      app.use(pinoHttp({ logger }));
    
  -   app.get('/', mainRouter);
      app.use("/users", userRouter);
      app.use("/auth", authRouter);
      app.use("/moods", moodRouter);
  +   app.use("/sleep_records", sleepRecordRouter);
    
      app.use(errorHandler); // always last
  + 
  +   // TODO: flesh the actual page here
  +   app.use(express.static(path.join(__dirname, './static')));
  +   app.get(/.*/, (req, res) => {
  +     res.sendFile(path.join(__dirname, './static/index.html')); });
    
      process.on('SIGTERM', shutdown);
      process.on('SIGINT', shutdown);

api/src/routes/sleepRecords.ts

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

api/src/schemas/index.ts

@@ -22,3 +22,8 @@ type LoginInput,
      type PasswordResetRequestInput,
      type PasswordResetInput
    } from '@app/schemas/auth.schema';
  + 
  + export {
  +   type CreateSleepRecordInput,
  +   CreateSleepRecordSchema
  + } from '@app/schemas/sleepRecord.schema';

api/src/schemas/sleepRecord.schema.ts

@@ -0,0 +1,9 @@
  + import { z } from 'zod';
  + 
  + export const CreateSleepRecordSchema = z.object({
  +   annotations: z.string().optional(),
  +   date: z.coerce.date(),
  +   average: z.number().min(0).max(15),
  + });
  + 
  + export type CreateSleepRecordInput = z.infer<typeof CreateSleepRecordSchema>;

api/src/services/sleepRecord.service.ts

@@ -0,0 +1,69 @@
  + import { prisma } from '@app/lib/prisma';
  + import { SleepRecord } from '@prisma/client';
  + 
  + import { CreateSleepRecordInput } from '@app/schemas';
  + 
  + export const createSleepRecord = async (
  +   userId: number, input: CreateSleepRecordInput
  + ): Promise<SleepRecord> => {
  +   return prisma.sleepRecord.create({
  +     data: {
  +       ...input,
  +       userId
  +     }
  +   });
  + };
  + 
  + export const getSleepRecordsByUserId = async (
  +   userId: number,
  +   params?: {
  +     limit?: number;
  +     page?: number;
  +     from?: string;
  +     to?: string;
  +   }
  + ): Promise<{ entries: SleepRecord[]; 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 ? {
  +       date: {
  +         ...(params.from && { gte: new Date(params.from) }),
  +         ...(params.to   && { lte: new Date(params.to)   }),
  +       }
  +     } : {}),
  +   };
  + 
  +   const [entries, total] = await Promise.all([
  +     prisma.sleepRecord.findMany({
  +       where,
  +       orderBy: { date: 'desc' },
  +       take: limit,
  +       skip,
  +     }),
  +     prisma.sleepRecord.count({ where }),
  +   ]);
  + 
  +   const totalPages = Math.ceil(total / limit);
  + 
  +   return {
  +     entries,
  +     total,
  +     page,
  +     nextPage: page < totalPages ? page + 1 : null,
  +   };
  + };
  + 
  + export const destroySleepRecordById = async (
  +   userId: number, id: number
  + ): Promise<SleepRecord> => {
  +   return await prisma.sleepRecord.delete({
  +     where: {
  +       id,
  +       userId
  +     }
  +   })
  + }