@drax/identity-back 0.0.8 → 0.0.10

package/src/routes/RoleRoutes.ts

@@ -0,0 +1,141 @@
+import {IPaginateResult, ValidationError} from "@drax/common-back";
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+import {IRole} from "../interfaces/IRole";
+import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
+import {PermissionService} from "../services/PermissionService.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+
+const roleService = RoleServiceFactory
+
+async function RoleRoutes(fastify, options) {
+
+    fastify.get('/api/permissions', async (request, reply): Promise<string[]> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.PermissionsRole)
+            let permissions = PermissionService.getPermissions()
+            return permissions
+        }catch (e){
+            console.error(e)
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    })
+
+    fastify.get('/api/roles/all', async (request, reply): Promise<IRole[]> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewRole)
+            let roles = await roleService.fetchAll()
+            return roles
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    })
+
+    fastify.get('/api/roles', async (request, reply): Promise<IPaginateResult> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewRole)
+            const page = request.query.page
+            const limit = request.query.limit
+            const search = request.query.search
+            let paginateResult = await roleService.paginate(page, limit, search)
+            return paginateResult
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    })
+
+    fastify.post('/api/roles', async (request, reply): Promise<IRole> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateRole)
+            const payload = request.body
+            let role = await roleService.create(payload)
+            return role
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+
+    })
+
+    fastify.put('/api/roles/:id', async (request, reply): Promise<IRole> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateRole)
+            const id = request.params.id
+            const payload = request.body
+            let role = await roleService.update(id, payload)
+            return role
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+
+    })
+
+    fastify.delete('/api/roles/:id', async (request, reply): Promise<any> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteRole)
+            const id = request.params.id
+            let r = await roleService.delete(id)
+            return r
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    })
+
+}
+
+export default RoleRoutes;
+export {RoleRoutes}

package/src/routes/UserRoutes.ts

@@ -0,0 +1,198 @@
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+import {IUser} from "../interfaces/IUser";
+import {IPaginateResult, ValidationError} from "@drax/common-back";
+import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+import BadCredentialsError from "../errors/BadCredentialsError.js";
+
+const userService = UserServiceFactory
+
+async function UserRoutes(fastify, options) {
+    fastify.post('/api/auth', async (request, reply) => {
+        try {
+            const username = request.body.username
+            const password = request.body.password
+            return await userService.auth(username, password)
+        } catch (e) {
+            console.error('/api/auth error', e)
+            if (e instanceof BadCredentialsError) {
+                reply.code(401)
+                reply.send({error: e.message})
+            }
+            reply.code(500)
+            reply.send({error: 'error.server'})
+        }
+    })
+
+
+
+
+    fastify.get('/api/me', async (request, reply): Promise<IUser | null> => {
+        try {
+            if (request.authUser) {
+                let user = await userService.findById(request.authUser.id)
+                delete user.password
+                return user
+            } else {
+                throw new UnauthorizedError()
+
+            }
+        } catch (e) {
+            if (e instanceof UnauthorizedError) {
+                reply.code(401)
+                reply.send({error: "Unauthorized"})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+
+
+    })
+
+    fastify.get('/api/users', async (request, reply): Promise<IPaginateResult> => {
+
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewUser)
+            const page = request.query.page
+            const limit = request.query.limit
+            const search = request.query.search
+            let paginateResult = await userService.paginate(page, limit, search)
+            return paginateResult
+        } catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+    })
+
+    fastify.post('/api/users', async (request, reply): Promise<IUser> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateUser)
+            const payload = request.body
+            let user = await userService.create(payload)
+            return user
+        } catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+
+    })
+
+    fastify.put('/api/users/:id', async (request, reply): Promise<IUser> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateUser)
+            const id = request.params.id
+            const payload = request.body
+            let user = await userService.update(id, payload)
+            return user
+        } catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            }
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+    })
+
+    fastify.delete('/api/users/:id', async (request, reply): Promise<any> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteUser)
+            const id = request.params.id
+            let r = await userService.delete(id)
+            return r
+        } catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+    })
+
+    fastify.post('/api/password', async (request, reply) => {
+        try {
+            if(!request.authUser){
+                throw new UnauthorizedError()
+            }
+            const userId = request.authUser.id
+            const currentPassword = request.body.currentPassword
+            const newPassword = request.body.newPassword
+            return await userService.changeOwnPassword(userId, currentPassword, newPassword)
+        } catch (e) {
+            console.error('/api/password error', e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+    })
+
+
+    fastify.post('/api/password/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateUser)
+            const userId = request.params.id
+            if(!userId){
+                throw new UnauthorizedError()
+            }
+            const newPassword = request.body.newPassword
+
+            return await userService.changeUserPassword(userId, newPassword)
+        } catch (e) {
+            console.error('/api/password error', e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'error.server'})
+            }
+        }
+    })
+
+}
+
+export default UserRoutes;
+export {UserRoutes}

package/src/services/PermissionService.ts

@@ -0,0 +1,26 @@
+const permissions: string[] = []
+
+class PermissionService{
+
+    static addPermission(permission: string){
+        if(PermissionService.hasPermission(permission)) return;
+        permissions.push(permission)
+    }
+
+    static removePermission(permission: string){
+        permissions.splice(permissions.indexOf(permission), 1)
+    }
+
+    static hasPermission(permission: string): boolean{
+        return permissions.includes(permission)
+    }
+
+    static getPermissions(): string[]{
+        return permissions
+    }
+
+}
+
+
+export default PermissionService
+export {PermissionService}

package/src/services/RoleService.ts

@@ -1,6 +1,9 @@
 import {IRole} from "../interfaces/IRole";
 import {IRoleRepository} from "../interfaces/IRoleRepository";
-import { IPaginateFilter} from "@drax/common-back"
+import {IPaginateFilter, IPaginateResult, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import {roleSchema} from "../zod/RoleZod.js";
+import {ZodError} from "zod";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
 
 class RoleService {
 
@@ -8,40 +11,62 @@ class RoleService {
 
     constructor(roleRepostitory: IRoleRepository) {
         this._repository = roleRepostitory
+        console.log("RoleService constructor")
     }
 
     async create(roleData: IRole): Promise<IRole> {
-        const role = await this._repository.create(roleData)
-        return role
+        try {
+            roleData.name = roleData?.name?.trim()
+            await roleSchema.parseAsync(roleData)
+            const role = await this._repository.create(roleData)
+            return role
+        } catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData)
+            }
+            throw e
+        }
     }
 
-    async update(_id: any, roleData: IRole) {
-        const role = await this._repository.update(_id, roleData)
-        return role
+    async update(id: any, roleData: IRole) {
+        try {
+            roleData.name = roleData?.name?.trim()
+            await roleSchema.parseAsync(roleData)
+            const currentRole = await this.findById(id)
+            if(currentRole.readonly){
+                throw new ValidationError([{field:'name', reason:"role.readonly", value:roleData.name}])
+            }
+            const role = await this._repository.update(id, roleData)
+            return role
+        } catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData)
+            }
+            throw e
+        }
     }
 
-    async delete(_id: any): Promise<boolean> {
-        const deletedRole = await this._repository.delete(_id);
+    async delete(id: any): Promise<boolean> {
+        const currentRole = await this.findById(id)
+        if(currentRole.readonly){
+            throw new UnauthorizedError()
+        }
+        const deletedRole = await this._repository.delete(id);
         return deletedRole;
     }
 
-    async findById(_id: any): Promise<IRole | null> {
-        const role : IRole =  await this._repository.findById(_id);
+    async findById(id: any): Promise<IRole | null> {
+        const role: IRole = await this._repository.findById(id);
         return role
     }
 
-    async paginate(filters ?: IPaginateFilter, page: number = 1, limit: number = 10): Promise<{ roles: IRole[], totalCount: number }> {
-
-        const query = {
-
-        }
-
-        const options = {
-            page: page,
-            limit: limit
-        }
+    async fetchAll(): Promise<IRole[]> {
+        const roles: IRole[] = await this._repository.fetchAll();
+        return roles
+    }
 
-        const pagination = await this._repository.paginate(query, options);
+    async paginate(page: number = 1, limit: number = 5, search?:string, filters ?: IPaginateFilter[]): Promise<IPaginateResult> {
+        const pagination = await this._repository.paginate(page, limit, search, filters);
         return pagination;
     }
 

package/src/services/UserService.ts

@@ -1,7 +1,11 @@
-import {IPaginateFilter} from "@drax/common-back"
-import {IUser} from "../interfaces/IUser";
-import {IUserRepository} from "../interfaces/IUserRepository";
+import type {IUser, IUserCreate, IUserUpdate} from "../interfaces/IUser";
+import type {IUserRepository} from "../interfaces/IUserRepository";
+import type {IPaginateFilter, IPaginateResult} from "@drax/common-back"
+import {ZodError} from "zod";
+import {ValidationError, ZodErrorToValidationError} from "@drax/common-back";
 import AuthUtils from "../utils/AuthUtils.js";
+import {createUserSchema, editUserSchema,} from "../zod/UserZod.js";
+import BadCredentialsError from "../errors/BadCredentialsError.js";
 
 class UserService {
 
@@ -9,35 +13,100 @@ class UserService {
 
     constructor(userRepository: IUserRepository) {
         this._repository = userRepository;
+        console.log("UserService constructor")
     }
 
-    async create(userData: IUser): Promise<IUser> {
+    async auth(username : string, password : string){
+        let user = null
+        console.log("auth username",username)
+        user = await this.findByUsername(username)
+        if (user && user.active && AuthUtils.checkPassword(password, user.password)) {
+            //TODO: Generar Sesion
+            const session = '123'
+            const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, session)
+            return {accessToken: accessToken}
+        }else{
+            throw new BadCredentialsError()
+        }
+    }
 
-        userData.name = userData?.name?.trim()
-        userData.username = userData.username.trim()
-        userData.password = AuthUtils.hashPassword(userData.password.trim())
+    async changeUserPassword(userId : string, newPassword : string){
+        const user = await this.findById(userId)
+        if(user){
+            newPassword =  AuthUtils.hashPassword(newPassword)
+            await this._repository.changePassword(userId, newPassword)
+            return true
+        }else{
+            throw new ValidationError([{field: 'userId', reason: 'validation.notFound'}])
+        }
+    }
 
-        const user: IUser = await this._repository.create(userData)
-        return user
+
+    async changeOwnPassword(userId : string, currentPassword : string, newPassword : string){
+        const user = await this.findById(userId)
+        if(user && user.active){
+            if (AuthUtils.checkPassword(currentPassword, user.password)) {
+                newPassword =  AuthUtils.hashPassword(newPassword)
+                await this._repository.changePassword(userId, newPassword)
+                return true
+            }else{
+                throw new ValidationError([{field: 'currentPassword', reason: 'validation.notMatch'}])
+            }
+
+        }else{
+            throw new BadCredentialsError()
+        }
     }
 
-    async update(_id: any, userData: IUser) {
 
+    async create(userData: IUserCreate): Promise<IUser> {
+        try{
+            userData.name = userData?.name?.trim()
+            userData.username = userData.username.trim()
+            userData.password = userData.password.trim()
+
+            await createUserSchema.parseAsync(userData)
+
+            userData.password = AuthUtils.hashPassword(userData.password.trim())
+
+            const user: IUser = await this._repository.create(userData)
+            return user
+        }catch (e){
+            if(e instanceof ZodError){
+                throw ZodErrorToValidationError(e,userData)
+            }
+            throw e
+        }
+
+
+    }
+
+    async update(id: any, userData: IUserUpdate) {
+        try{
         userData.name = userData.name.trim()
         userData.username = userData.username.trim()
         delete userData.password
 
-        const user: IUser = await this._repository.update(_id, userData)
+        await editUserSchema.parseAsync(userData)
+
+
+        const user: IUser = await this._repository.update(id, userData)
         return user
+        }catch (e){
+            if(e instanceof ZodError){
+                throw ZodErrorToValidationError(e,userData)
+            }
+            throw e
+        }
     }
 
-    async delete(_id: any): Promise<boolean> {
-        const deletedRole: boolean = await this._repository.delete(_id);
+    async delete(id: any): Promise<boolean> {
+        const deletedRole: boolean = await this._repository.delete(id);
         return deletedRole;
     }
 
-    async findById(_id: any): Promise<IUser | null> {
-        const user: IUser = await this._repository.findById(_id);
+    async findById(id: any): Promise<IUser> {
+        const user: IUser = await this._repository.findById(id);
         return user
     }
 
@@ -46,20 +115,9 @@ class UserService {
         return user
     }
 
-    async paginate(filters ?: IPaginateFilter, page : number = 1, limit : number = 10): Promise<{
-        roles: IUser[],
-        totalCount: number
-    }> {
-
-        const query = {}
-
-        const options = {
-            page: page,
-            limit: limit
-        }
+    async paginate( page : number = 1, limit : number = 10, search?: string, filters ?: IPaginateFilter[]): Promise<IPaginateResult> {
 
-        const pagination = await this._repository.paginate(query, options);
-        console.log("pagination",pagination)
+        const pagination = await this._repository.paginate( page, limit, search, filters);
         return pagination;
     }
 }

package/src/utils/AuthUtils.ts

@@ -1,8 +1,19 @@
 import bcryptjs from "bcryptjs";
-import jsonwebtoken, {SignOptions} from "jsonwebtoken";
+import jsonwebtoken, {SignOptions, VerifyOptions} from "jsonwebtoken";
 
 class AuthUtils{
 
+    static verifyToken(token : string) {
+        const JWT_SECRET = process.env.JWT_SECRET
+        if(!JWT_SECRET){
+            throw new Error("JWT_SECRET ENV must be provided")
+        }
+        const options : VerifyOptions = {
+            algorithms: ['HS256'],
+        }
+        return jsonwebtoken.verify(token, JWT_SECRET, options)
+    }
+
     static hashPassword(password : string) :string {
         if (!password) {
             throw new Error("password must be provided")
@@ -17,25 +28,29 @@ class AuthUtils{
         return bcryptjs.compareSync(password, hashPassword);
     }
 
-    static tokenSignPayload(userId : string, username: string, session : string) {
+    static tokenSignPayload(userId : string, username: string, roleId: string, session : string) {
         return {
             id: userId,
             username: username,
+            roleId: roleId,
             session: session
         };
     }
 
-    static generateToken(userId : string, username: string, session : string) {
-        const payload = AuthUtils.tokenSignPayload(userId, username, session)
+    static generateToken(userId : string, username: string, roleId: string,  session : string) {
+        const payload = AuthUtils.tokenSignPayload(userId, username, roleId, session)
 
-        const JWT_SECRET = process.env.JWT_SECRET ? process.env.JWT_SECRET :'KRgDV3CeR5lVhsFF'
+        const JWT_SECRET = process.env.JWT_SECRET
+        if(!JWT_SECRET){
+            throw new Error("JWT_SECRET ENV must be provided")
+        }
 
         const options : SignOptions = {
-            expiresIn: process.env.JWT_LOGIN_EXPIRED_IN || '1h',
+            expiresIn: process.env.JWT_EXPIRATION || '1h',
             jwtid: userId,
             algorithm: 'HS256',
             audience: username,
-            issuer: process.env.ISSUER? process.env.ISSUER : 'drax'
+            issuer: process.env.JWT_ISSUER? process.env.JWT_ISSUER : 'drax'
         }
 
         let token = jsonwebtoken.sign(