Merge pull request #48 from waldemarnt/add-respositories

Refatoração para adicionar camada de Repository

Author: waldemarnt

package.json

@@ -13,7 +13,7 @@
     "test:functional": "dotenv -e .env -- jest --projects ./test --runInBand",
     "test:unit": "dotenv -e .env -- jest",
     "style:check": "prettier --check src/**/*.ts test/**/*.ts",
-    "style:fix": "prettier --write src/**/*.ts' test/**/*.ts"
+    "style:fix": "prettier --write src/**/*.ts test/**/*.ts"
   },
   "engines": {
     "node": "16"

src/api-schema.json

@@ -212,15 +212,15 @@
             "name": "orderBy",
             "in": "query",
             "required": false,
-            "schema":{
+            "schema": {
               "$ref": "#/components/schemas/orderBy"
             }
           },
           {
             "name": "orderField",
             "in": "query",
             "required": false,
-            "schema":{
+            "schema": {
               "$ref": "#/components/schemas/orderField"
             }
           }
@@ -252,7 +252,10 @@
       "orderBy": {
         "type": "string",
         "example": "desc",
-        "enum": ["asc", "desc"],
+        "enum": [
+          "asc",
+          "desc"
+        ],
         "default": "desc"
       },
       "orderField": {
@@ -288,13 +291,18 @@
         "type": "number",
         "example": -10.55
       },
-      "id":{
+      "id": {
         "type": "string",
         "example": "5e8131eba7768d9e4f06c884"
       },
       "beachPosition": {
         "type": "string",
-        "enum": ["N", "S", "W", "E"],
+        "enum": [
+          "N",
+          "S",
+          "W",
+          "E"
+        ],
         "example": "S"
       },
       "forecastPropertyKey": {
@@ -340,12 +348,17 @@
             "$ref": "#/components/schemas/beachPosition"
           }
         },
-        "required": ["name", "lat", "lng", "position"]
+        "required": [
+          "name",
+          "lat",
+          "lng",
+          "position"
+        ]
       },
       "TimeForecast": {
-        "type":"array",
+        "type": "array",
         "items": {
-          "type":"object",
+          "type": "object",
           "properties": {
             "time": {
               "type": "string",
@@ -542,5 +555,4 @@
       }
     }
   }
-}
-
+}

src/controllers/beaches.ts

@@ -1,20 +1,22 @@
 import { Controller, Post, ClassMiddleware } from '@overnightjs/core';
 import { Request, Response } from 'express';
-import { Beach } from '@src/models/beach';
 import { authMiddleware } from '@src/middlewares/auth';
 import { BaseController } from '.';
+import { BeachRepository } from '@src/repositories';
 
 @Controller('beaches')
 @ClassMiddleware(authMiddleware)
 export class BeachesController extends BaseController {
+  constructor(private beachRepository: BeachRepository) {
+    super();
+  }
   @Post('')
   public async create(req: Request, res: Response): Promise<void> {
     try {
-      const beach = new Beach({
+      const result = await this.beachRepository.create({
         ...req.body,
         ...{ userId: req.context?.userId },
       });
-      const result = await beach.save();
       res.status(201).send(result);
     } catch (error) {
       this.sendCreateUpdateErrorResponse(res, error);

src/controllers/forecast.ts

@@ -5,13 +5,13 @@ import {
   Middleware,
 } from '@overnightjs/core';
 import { Request, Response } from 'express';
-import { Beach } from '@src/models/beach';
 import { BeachForecast, Forecast } from '@src/services/forecast';
 import { authMiddleware } from '@src/middlewares/auth';
 import { BaseController } from '.';
 import logger from '@src/logger';
 import rateLimit from 'express-rate-limit';
 import ApiError from '@src/util/errors/api-error';
+import { BeachRepository } from '@src/repositories';
 
 const forecast = new Forecast();
 
@@ -34,6 +34,10 @@ const rateLimiter = rateLimit({
 @Controller('forecast')
 @ClassMiddleware(authMiddleware)
 export class ForecastController extends BaseController {
+  constructor(private beachRepository: BeachRepository) {
+    super();
+  }
+
   @Get('')
   @Middleware(rateLimiter)
   public async getForecastForgeLoggedUser(
@@ -48,7 +52,19 @@ export class ForecastController extends BaseController {
         orderBy?: 'asc' | 'desc';
         orderField?: keyof BeachForecast;
       } = req.query;
-      const beaches = await Beach.find({ userId: req.context?.userId });
+
+      if (!req.context.userId) {
+        this.sendErrorResponse(res, {
+          code: 500,
+          message: 'Something went wrong',
+        });
+        logger.error('Missing userId');
+        return;
+      }
+
+      const beaches = await this.beachRepository.findAllBeachesForUser(
+        req.context.userId
+      );
       const forecastData = await forecast.processForecastForBeaches(
         beaches,
         orderBy,

src/controllers/index.ts

@@ -1,12 +1,18 @@
 import { Response } from 'express';
-import mongoose from 'mongoose';
-import { CUSTOM_VALIDATION } from '@src/models/user';
 import logger from '@src/logger';
 import ApiError, { APIError } from '@src/util/errors/api-error';
+import {
+  DatabaseError,
+  DatabaseUnknownClientError,
+  DatabaseValidationError,
+} from '@src/repositories/repository';
 
 export abstract class BaseController {
   protected sendCreateUpdateErrorResponse(res: Response, error: unknown): void {
-    if (error instanceof mongoose.Error.ValidationError) {
+    if (
+      error instanceof DatabaseValidationError ||
+      error instanceof DatabaseUnknownClientError
+    ) {
       const clientErrors = this.handleClientErrors(error);
       res.status(clientErrors.code).send(
         ApiError.format({
@@ -22,16 +28,11 @@ export abstract class BaseController {
     }
   }
 
-  private handleClientErrors(error: mongoose.Error.ValidationError): {
+  private handleClientErrors(error: DatabaseError): {
     code: number;
     error: string;
   } {
-    const duplicatedKindErrors = Object.values(error.errors).filter(
-      (err) =>
-        err.name === 'ValidatorError' &&
-        err.kind === CUSTOM_VALIDATION.DUPLICATED
-    );
-    if (duplicatedKindErrors.length) {
+    if (error instanceof DatabaseValidationError) {
       return { code: 409, error: error.message };
     }
     return { code: 400, error: error.message };

src/controllers/users.ts

@@ -1,17 +1,20 @@
 import { Controller, Post, Get, Middleware } from '@overnightjs/core';
 import { Response, Request } from 'express';
-import { User } from '@src/models/user';
 import AuthService from '@src/services/auth';
 import { BaseController } from './index';
 import { authMiddleware } from '@src/middlewares/auth';
+import { UserRepository } from '@src/repositories';
 
 @Controller('users')
 export class UsersController extends BaseController {
+  constructor(private userRepository: UserRepository) {
+    super();
+  }
+
   @Post('')
   public async create(req: Request, res: Response): Promise<void> {
     try {
-      const user = new User(req.body);
-      const newUser = await user.save();
+      const newUser = await this.userRepository.create(req.body);
       res.status(201).send(newUser);
     } catch (error) {
       this.sendCreateUpdateErrorResponse(res, error);
@@ -20,7 +23,7 @@ export class UsersController extends BaseController {
 
   @Post('authenticate')
   public async authenticate(req: Request, res: Response): Promise<Response> {
-    const user = await User.findOne({ email: req.body.email });
+    const user = await this.userRepository.findOneByEmail(req.body.email);
     if (!user) {
       return this.sendErrorResponse(res, {
         code: 401,
@@ -38,14 +41,20 @@ export class UsersController extends BaseController {
     }
     const token = AuthService.generateToken(user.id);
 
-    return res.send({ ...user.toJSON(), ...{ token } });
+    return res.send({ ...user, ...{ token } });
   }
 
   @Get('me')
   @Middleware(authMiddleware)
   public async me(req: Request, res: Response): Promise<Response> {
     const userId = req.context?.userId;
-    const user = await User.findOne({ _id: userId });
+    if (!userId) {
+      return this.sendErrorResponse(res, {
+        code: 404,
+        message: 'user id not provided',
+      });
+    }
+    const user = await this.userRepository.findOneById(userId);
     if (!user) {
       return this.sendErrorResponse(res, {
         code: 404,

src/models/beach.ts

@@ -1,4 +1,5 @@
-import mongoose, { Document, Model, Schema } from 'mongoose';
+import mongoose, { Schema } from 'mongoose';
+import { BaseModel } from '.';
 
 export enum GeoPosition {
   S = 'S',
@@ -7,15 +8,18 @@ export enum GeoPosition {
   N = 'N',
 }
 
-export interface Beach {
-  _id?: string;
+export interface Beach extends BaseModel {
   name: string;
   position: GeoPosition;
   lat: number;
   lng: number;
   userId: string;
 }
 
+export interface ExistingBeach extends Beach {
+  id: string;
+}
+
 const schema = new mongoose.Schema(
   {
     lat: { type: Number, required: true },
@@ -27,13 +31,12 @@ const schema = new mongoose.Schema(
   {
     toJSON: {
       transform: (_, ret): void => {
-        ret.id = ret._id;
+        ret.id = ret._id.toString();
         delete ret._id;
         delete ret.__v;
       },
     },
   }
 );
 
-interface BeachModel extends Omit<Beach, '_id'>, Document {}
-export const Beach: Model<BeachModel> = mongoose.model('Beach', schema);
+export const Beach = mongoose.model<Beach>('Beach', schema);

src/models/index.ts

@@ -0,0 +1,2 @@
+//eslint-disable-next-line
+export interface BaseModel {}

src/models/user.ts

@@ -1,20 +1,22 @@
-import mongoose, { Document, Model } from 'mongoose';
+import mongoose, { Document } from 'mongoose';
 import AuthService from '@src/services/auth';
 import logger from '@src/logger';
+import { BaseModel } from '.';
 
-export interface User {
-  _id?: string;
+export interface User extends BaseModel {
   name: string;
   email: string;
   password: string;
 }
 
+export interface ExistingUser extends User {
+  id: string;
+}
+
 export enum CUSTOM_VALIDATION {
   DUPLICATED = 'DUPLICATED',
 }
 
-interface UserModel extends Omit<User, '_id'>, Document {}
-
 const schema = new mongoose.Schema(
   {
     name: { type: String, required: true },
@@ -27,7 +29,7 @@ const schema = new mongoose.Schema(
   {
     toJSON: {
       transform: (_, ret): void => {
-        ret.id = ret._id;
+        ret.id = ret._id.toString();
         delete ret._id;
         delete ret.__v;
       },
@@ -47,7 +49,7 @@ schema.path('email').validate(
   CUSTOM_VALIDATION.DUPLICATED
 );
 
-schema.pre<UserModel>('save', async function (): Promise<void> {
+schema.pre<User & Document>('save', async function (): Promise<void> {
   if (!this.password || !this.isModified('password')) {
     return;
   }
@@ -58,5 +60,4 @@ schema.pre<UserModel>('save', async function (): Promise<void> {
     logger.error(`Error hashing the password for the user ${this.name}`, err);
   }
 });
-
-export const User: Model<UserModel> = mongoose.model('User', schema);
+export const User = mongoose.model<User>('User', schema);

src/repositories/beachMongoDBRepository.ts

@@ -0,0 +1,16 @@
+import { DefaultMongoDBRepository } from './defaultMongoDBRepository';
+import { Beach } from '@src/models/beach';
+import { BeachRepository } from '.';
+
+export class BeachMongoDBRepository
+  extends DefaultMongoDBRepository<Beach>
+  implements BeachRepository
+{
+  constructor(beachModel = Beach) {
+    super(beachModel);
+  }
+
+  async findAllBeachesForUser(userId: string) {
+    return await this.find({ userId });
+  }
+}