Swagger

package.json

@@ -18,14 +18,16 @@
     "express": "^4.17.1",
     "mongoose": "^5.10.9",
     "morgan": "^1.10.0",
-    "node-config-ts": "^3.1.0"
+    "node-config-ts": "^3.1.0",
+    "swagger-ui-express": "^4.1.4"
   },
   "devDependencies": {
     "@types/bcrypt": "^3.0.0",
     "@types/cors": "^2.8.8",
     "@types/express": "^4.17.8",
     "@types/mongoose": "^5.7.36",
     "@types/morgan": "^1.9.1",
+    "@types/swagger-ui-express": "^4.1.2",
     "nodemon": "^2.0.5",
     "rimraf": "^3.0.2",
     "ts-node": "^9.0.0",

src/app.ts

@@ -4,6 +4,8 @@ import router from "./router";
 // import { config } from 'node-config-ts'
 
 import morgan from 'morgan'
+import swaggerUi from 'swagger-ui-express';
+import swaggerDocument from './swagger.json'
 
 class App {
     private port = 5000
@@ -14,22 +16,25 @@ class App {
         this.initRoutes()
     }
 
-    public initServer = async () => {
+    async initServer() {
         try {
-            this.app.listen(this.port, () => console.log(`Listening on http://${'localhost'}:${this.port}/`))
+            this.app.listen(this.port, () => 
+            console.log(`Listening on http://${'localhost'}:${this.port}/`))
         } catch (error) {
             console.error(error)
         }
     }
 
-    private config = () => {
+    private config() {
         this.app.use(cors())
         this.app.use(express.json())
         this.app.use(express.urlencoded({ extended: false }))
+        this.app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument))
+
         if (process.env.NODE_ENV !== 'production') this.app.use(morgan('dev'))
     }
 
-    private initRoutes = () => {
+    private initRoutes() {
         router(this.app)
     }
 }

src/database.ts

@@ -13,11 +13,11 @@ class Database {
         }
     }
 
-    public init = async () => {
+    async init () {
         await this.connect()
     }
 
-    private connect = async () => {
+    private async connect() {
         try {
             await mongoose.connect(this.URI, this.config)
             console.log('database conected')

src/modules/users/model.ts → src/modules/users/busiessController.ts

@@ -1,24 +1,18 @@
-/*No sabe nada del controlador y de la base de datos, solo recibe los datos del controlador 
-y se los manda a la capa de la base de datos (dao)*/
 import Dao from "./dao";
 import { Interface } from "./modelSchema";
 
-class Model{
+class BusniesController{
     public show = async (id: string): Promise<Interface | null> => 
         await Dao.show(id)
 
-
     public put = async (id: string, model: any): Promise<Interface | null> => 
         await Dao.put(id, model)
 
-
     public signIn = async (username: string, password: string): Promise<Interface | null> => 
         await Dao.signIn(username, password)
 
-
     public signUp = async (model: any): Promise<Interface | null> =>
         await Dao.signUp(model)
 }
 
-
-export default new Model() 
+export default new BusniesController() 

src/modules/users/controller.ts

@@ -1,44 +1,39 @@
 import { Request, Response } from 'express'
 import Dto from "./dto";
-import Model from './model'
+import busiessController from './busiessController'
 
-class Controller{
-    public show = async (req: Request, res: Response): Promise<Response> => {
+import { handlerError } from "../../services/handlerError";
+
+class Controller {
+    async show (req: Request, res: Response): Promise<Response> {
         try {
             const id = req.params.id
 
-            const model = await Model.show(id)
+            const model = await busiessController.show(id)
             if(!model) return res.status(404).json({msg: 'El recurso no existe' }) 
-
+            
             return res.status(200).json(Dto.single(model))
         } catch (error) {
-            return res.status(422).json({ code: error.code, msg: error.message })
+            return handlerError(error.code, error.message, res)
         }
     }
 
-    public put = async (req: Request, res: Response): Promise<Response> => {
+    async put (req: Request, res: Response): Promise<Response> {
         try {
-            let model: any = {}
-            if(req.body.name) model.name = req.body.name
-            if(req.body.namusernamee) model.username = req.body.username
-            if(req.body.password) model.password = req.body.password
-
-            const newModel = await Model.put(req.params.id, model)
+            const model: any = {... req.body}
+
+            const newModel = await busiessController.put(req.params.id, model)
             if(!newModel) return res.status(404).json({msg: 'El recurso no existe' }) 
 
             return res.status(200).json(Dto.single(newModel))
         } catch (error) {
-            return res.status(422).json({ code: error.code, msg: error.message })
+            return handlerError(error.code, error.message, res)
         }
     }
 
-    public signUp = async (req: Request, res: Response): Promise<Response> => {
+    async signUp (req: Request, res: Response): Promise<Response> {
         try {
-            if(!req.body.name) return res.status(400).json({msg: 'falta el nombre'})
-            if(!req.body.username) return res.status(400).json({msg: 'falta el username'})
-            if(!req.body.password) return res.status(400).json({msg: 'falta el password'})
-
-            const newModel = await Model.signUp({
+            const newModel = await busiessController.signUp({
                 username: req.body.username,
                 name: req.body.name,
                 password: req.body.password
@@ -47,21 +42,20 @@ class Controller{
 
             return res.status(201).json(Dto.single(newModel))
         } catch (error) {
-            return res.status(422).json({ code: error.code, msg: error.message })
+            return handlerError(error.code, error.message, res)
         }
     }
 
-    public signIn = async (req: Request, res: Response) => {
+    async signIn (req: Request, res: Response) {
         try {
-            if(!req.body.username) return res.status(400).json({msg: 'falta el username'})
-            if(!req.body.password) return res.status(400).json({msg: 'falta el password'})
+            if(!req.body.username) return res.status(400).json({ msg: 'Error en username o password' })
 
-            const model = await Model.signIn(req.body.username, req.body.password)
-            if(!model) return res.status(404).json({msg: 'Erorr en username o password' }) 
+            const model = await busiessController.signIn(req.body.username, req.body.password)
+            if(!model) return res.status(404).json({msg: 'Error en username o password' }) 
 
             return res.status(200).json(Dto.single(model))
         } catch (error) {
-            return res.status(422).json({ code: error.code, msg: error.message })
+            return handlerError(error.code, error.message, res)
         }
     }
 }

src/modules/users/dao.ts

@@ -1,37 +1,33 @@
-/* Recien trabajamos con las consulatas de la base de datos */
-import { response } from 'express'
 import ModelSchema, { Interface } from './modelSchema'
+import { comparePassword, encryptPassword } from "../../services/encriptor";
 
 class Dao{
-    public show = async (id: string): Promise<Interface | null> => {
-        // const model = await ModelSchema.findById(id)
-        // if(!model) return null
-        // return model
-
-        return new Promise((resolve, reject) => ModelSchema.findById({id: id}, (err, doc) => {
-            if(err) return reject(err)
-            return resolve(doc)
-        }))
+    async show (id: string): Promise<Interface | null> {
+        const model = await ModelSchema.findById(id)
+        if(!model) return null
+        return model
     }
 
-    public put = async (id: string, newModel: any): Promise<Interface | null> => {
+    async put (id: string, newModel: Interface): Promise<Interface | null> {
+        if(newModel.password) newModel.password = await encryptPassword(newModel.password)
         const updated = await ModelSchema.findByIdAndUpdate(id, newModel)
         if(!updated) return null
         return updated
     }
 
-    public signIn = async (username: string, password: string): Promise<Interface | null> => {
+    async signIn (username: string, password: string): Promise<Interface | null> {
         const model = await ModelSchema.findOne({username: username})
         if(!model) return null
 
-        const isMatch = await model.comparePassword(password)
+        const isMatch = await comparePassword(password, model.password)
         if (isMatch) return model
 
         return null
     }
 
-    public signUp = async (model: Interface): Promise<Interface> => {
+    async signUp (model: Interface): Promise<Interface> {
         const newModel = new ModelSchema(model)
+        newModel.password = await encryptPassword(newModel.password)
         await newModel.save()
         return newModel
     }

src/modules/users/dto.ts

@@ -1,12 +1,10 @@
-/* Los parametros que recivo del controlador despues de que vea obtenido la  
-respuesta de la base de datos aqui los transformo para poder mandarlos bonito*/
 import { Interface } from "./modelSchema";
 
-class Dto {
+class UserDto {
     public single = (model: Interface) => ({
       name: model.name,
       usermane: model.username
     })
 }
 
-export default new Dto()
+export default new UserDto()

src/modules/users/modelSchema.ts

@@ -1,16 +1,12 @@
-
 import { model, Schema, Document } from 'mongoose'
-import bcrypt from 'bcrypt'
-
 
 export interface Interface extends Document {
     name: string
     username: string
     password: string
-    comparePassword: (password: string) => Promise<boolean>
-    encryptPassword: (password: string) => Promise<string>
 }
 
+//add validators
 const modelSchema: Schema = new Schema(
     {
         name: {
@@ -26,27 +22,8 @@ const modelSchema: Schema = new Schema(
             type: String,
             required: true,
         },
-
     },
     { versionKey: false }
 )
 
-modelSchema.pre<Interface>('save', async function (next) {
-    const schema = this
-    if (!schema.isModified('password')) return next()
-
-    schema.password = await schema.encryptPassword(schema.password)
-    next()
-})
-
-modelSchema.methods.comparePassword = async function (password: string): Promise<boolean> {
-    return await bcrypt.compare(password, this.password)
-}
-
-modelSchema.methods.encryptPassword = async function (password: string): Promise<string> {
-    const salt = await bcrypt.genSalt(10)
-    const hash = await bcrypt.hash(password, salt)
-    return hash
-}
-
 export default model<Interface>('users', modelSchema)

src/modules/users/routes.ts

@@ -3,10 +3,10 @@ const router = Router()
 
 import controller from './controller'
 
-router.get('/user/:id', controller.show)
-router.put('/user/:id', controller.put)
+router.get('/users/:id', controller.show)
+router.put('/users/:id', controller.put)
 
-router.post('/user/signin', controller.signIn)
-router.post('/user/signup', controller.signUp)
+router.post('/users/signin', controller.signIn)
+router.post('/users/signup', controller.signUp)
 
 export { router as users }

src/services/encriptor.ts

@@ -0,0 +1,13 @@
+import bcrypt from 'bcrypt'
+
+async function comparePassword (password: string, encrytedPassword: string): Promise<boolean>{
+    return await bcrypt.compare(password, encrytedPassword)
+}
+
+
+async function encryptPassword (password: string): Promise<string> {
+    const salt = await bcrypt.genSalt(10)
+    return await bcrypt.hash(password, salt)
+}
+
+export { encryptPassword, comparePassword }

src/services/handlerError.ts

@@ -0,0 +1,7 @@
+import { Response } from "express";
+
+function handlerError(errorCode: number, errorMsg: string, res: Response){
+    return res.status(500).json({code:errorCode ,msg: errorMsg})
+}
+
+export { handlerError }