@drax/identity-back 0.0.14 → 0.0.16

package/src/routes/TenantRoutes.ts

@@ -0,0 +1,178 @@
+import {IPaginateResult, ValidationError} from "@drax/common-back";
+import TenantServiceFactory from "../factory/TenantServiceFactory.js";
+import {ITenant} from "../interfaces/ITenant";
+import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
+import {PermissionService} from "../services/PermissionService.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+
+
+
+async function TenantRoutes(fastify, options) {
+
+    fastify.get('/api/tenants/:id', async (request, reply): Promise<ITenant> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
+            const id = request.params.id
+            const tenantService = TenantServiceFactory()
+            let tenant = await tenantService.findById(id)
+            return tenant
+        } 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/tenants/name/:name', async (request, reply): Promise<ITenant> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
+            const name = request.params.name
+            const tenantService = TenantServiceFactory()
+            let tenant = await tenantService.findByName(name)
+            return tenant
+        } 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/tenants/all', async (request, reply): Promise<ITenant[]> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
+            const tenantService = TenantServiceFactory()
+            let tenants = await tenantService.fetchAll()
+            if(request.rbac.getAuthUser.tenantId){
+                return tenants.filter(t => t.id === request.rbac.getAuthUser.tenantId)
+            }else{
+                return tenants
+            }
+        } 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/tenants', async (request, reply): Promise<IPaginateResult> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.ViewTenant)
+            const page = request.query.page
+            const limit = request.query.limit
+            const search = request.query.search
+            const tenantService = TenantServiceFactory()
+            let paginateResult = await tenantService.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/tenants', async (request, reply): Promise<ITenant> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateTenant)
+            const payload = request.body
+            const tenantService = TenantServiceFactory()
+            let tenant = await tenantService.create(payload)
+            return tenant
+        } 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/tenants/:id', async (request, reply): Promise<ITenant> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateTenant)
+            const id = request.params.id
+            const payload = request.body
+            const tenantService = TenantServiceFactory()
+
+            let tenant = await tenantService.update(id, payload)
+            return tenant
+        } 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/tenants/:id', async (request, reply): Promise<any> => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteTenant)
+            const id = request.params.id
+            const tenantService = TenantServiceFactory()
+            let r = await tenantService.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 TenantRoutes;
+export {TenantRoutes}

package/src/routes/UserRoutes.ts

@@ -5,13 +5,12 @@ 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
+            const userService = UserServiceFactory()
             return await userService.auth(username, password)
         } catch (e) {
             console.error('/api/auth error', e)
@@ -30,6 +29,7 @@ async function UserRoutes(fastify, options) {
     fastify.get('/api/me', async (request, reply): Promise<IUser | null> => {
         try {
             if (request.authUser) {
+                const userService = UserServiceFactory()
                 let user = await userService.findById(request.authUser.id)
                 delete user.password
                 return user
@@ -60,9 +60,15 @@ async function UserRoutes(fastify, options) {
             const page = request.query.page
             const limit = request.query.limit
             const search = request.query.search
-            let paginateResult = await userService.paginate(page, limit, search)
+            const userService = UserServiceFactory()
+            const filters = []
+            if(request.rbac.getAuthUser.tenantId){
+                filters.push({field: 'tenant', operator: '$eq', value: request.rbac.getAuthUser.tenantId})
+            }
+            let paginateResult = await userService.paginate(page, limit, search, filters)
             return paginateResult
         } catch (e) {
+            console.log("/api/users",e)
             if (e instanceof ValidationError) {
                 reply.statusCode = e.statusCode
                 reply.send({error: e.message, inputErrors: e.errors})
@@ -80,6 +86,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.CreateUser)
             const payload = request.body
+            const userService = UserServiceFactory()
             let user = await userService.create(payload)
             return user
         } catch (e) {
@@ -102,6 +109,7 @@ async function UserRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateUser)
             const id = request.params.id
             const payload = request.body
+            const userService = UserServiceFactory()
             let user = await userService.update(id, payload)
             return user
         } catch (e) {
@@ -126,6 +134,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.DeleteUser)
             const id = request.params.id
+            const userService = UserServiceFactory()
             let r = await userService.delete(id)
             return r
         } catch (e) {
@@ -150,6 +159,7 @@ async function UserRoutes(fastify, options) {
             const userId = request.authUser.id
             const currentPassword = request.body.currentPassword
             const newPassword = request.body.newPassword
+            const userService = UserServiceFactory()
             return await userService.changeOwnPassword(userId, currentPassword, newPassword)
         } catch (e) {
             console.error('/api/password error', e)
@@ -175,7 +185,7 @@ async function UserRoutes(fastify, options) {
                 throw new UnauthorizedError()
             }
             const newPassword = request.body.newPassword
-
+            const userService = UserServiceFactory()
             return await userService.changeUserPassword(userId, newPassword)
         } catch (e) {
             console.error('/api/password error', e)

package/src/services/RoleService.ts

@@ -43,10 +43,7 @@ class RoleService {
     }
 
     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;
     }

package/src/services/TenantService.ts

@@ -0,0 +1,74 @@
+import {ITenant} from "../interfaces/ITenant";
+import {ITenantRepository} from "../interfaces/ITenantRepository";
+import {IPaginateFilter, IPaginateResult, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import {tenantSchema} from "../zod/TenantZod.js";
+import {ZodError} from "zod";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+
+class TenantService {
+
+    _repository: ITenantRepository
+
+    constructor(tenantRepostitory: ITenantRepository) {
+        this._repository = tenantRepostitory
+        console.log("TenantService constructor")
+    }
+
+    async create(tenantData: ITenant): Promise<ITenant> {
+        try {
+            tenantData.name = tenantData?.name?.trim()
+            await tenantSchema.parseAsync(tenantData)
+            const tenant = await this._repository.create(tenantData)
+            return tenant
+        } catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, tenantData)
+            }
+            throw e
+        }
+    }
+
+    async update(id: any, tenantData: ITenant) {
+        try {
+            tenantData.name = tenantData?.name?.trim()
+            await tenantSchema.parseAsync(tenantData)
+            const tenant = await this._repository.update(id, tenantData)
+            return tenant
+        } catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, tenantData)
+            }
+            throw e
+        }
+    }
+
+    async delete(id: any): Promise<boolean> {
+        const currentTenant = await this.findById(id)
+        const deletedTenant = await this._repository.delete(id);
+        return deletedTenant;
+    }
+
+    async findById(id: any): Promise<ITenant | null> {
+        const tenant: ITenant = await this._repository.findById(id);
+        return tenant
+    }
+
+    async findByName(name: string): Promise<ITenant | null> {
+        const tenant: ITenant = await this._repository.findByName(name);
+        return tenant
+    }
+
+    async fetchAll(): Promise<ITenant[]> {
+        const tenants: ITenant[] = await this._repository.fetchAll();
+        return tenants
+    }
+
+    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;
+    }
+
+
+}
+
+export default TenantService

package/src/services/UserService.ts

@@ -23,7 +23,7 @@ class UserService {
         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)
+            const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, user.tenant?.id, session)
             return {accessToken: accessToken}
         }else{
             throw new BadCredentialsError()

package/src/utils/AuthUtils.ts

@@ -30,17 +30,18 @@ class AuthUtils{
         return bcryptjs.compareSync(password, hashPassword);
     }
 
-    static tokenSignPayload(userId : string, username: string, roleId: string, session : string) {
+    static tokenSignPayload(userId : string, username: string, roleId: string, tenantId: string, session : string) {
         return {
             id: userId,
             username: username,
             roleId: roleId,
+            tenantId: tenantId,
             session: session
         };
     }
 
-    static generateToken(userId : string, username: string, roleId: string,  session : string) {
-        const payload = AuthUtils.tokenSignPayload(userId, username, roleId, session)
+    static generateToken(userId : string, username: string, roleId: string,  tenantId: string, session : string) {
+        const payload = AuthUtils.tokenSignPayload(userId, username, roleId, tenantId, session)
 
         const JWT_SECRET = DraxConfig.getOrLoad(IdentityConfig.JwtSecret)
         if(!JWT_SECRET){

package/src/zod/TenantZod.ts

@@ -0,0 +1,14 @@
+import { object, string } from "zod"
+
+const tenantSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+
+
+})
+
+
+export default tenantSchema
+
+export {tenantSchema}