@drax/identity-back 0.5.3 → 0.5.4

package/dist/routes/RoleRoutes.js

@@ -1,211 +1,15 @@
-import { ValidationError, UnauthorizedError } from "@drax/common-back";
-import RoleServiceFactory from "../factory/RoleServiceFactory.js";
-import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
-import { PermissionService } from "../services/PermissionService.js";
+import RoleController from "../controllers/RoleController.js";
 async function RoleRoutes(fastify, options) {
-    fastify.get('/api/permissions', async (request, reply) => {
-        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/:id', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewRole);
-            const id = request.params.id;
-            const roleService = RoleServiceFactory();
-            let role = await roleService.findById(id);
-            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.get('/api/roles/name/:name', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewRole);
-            const name = request.params.name;
-            const roleService = RoleServiceFactory();
-            let role = await roleService.findByName(name);
-            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.get('/api/roles/all', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewRole);
-            const roleService = RoleServiceFactory();
-            let roles = await roleService.fetchAll();
-            if (request.rbac.getRole?.childRoles?.length > 0) {
-                return roles.filter(role => request.rbac.getRole.childRoles.some(childRole => childRole.id === role.id));
-            }
-            else {
-                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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewRole);
-            const page = request.query.page;
-            const limit = request.query.limit;
-            const orderBy = request.query.orderBy;
-            const order = request.query.order;
-            const search = request.query.search;
-            const roleService = RoleServiceFactory();
-            let paginateResult = await roleService.paginate({ page, limit, search, orderBy, order });
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.CreateRole);
-            const payload = request.body;
-            const roleService = RoleServiceFactory();
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.UpdateRole);
-            const id = request.params.id;
-            const payload = request.body;
-            const roleService = RoleServiceFactory();
-            const currentRole = await roleService.findById(id);
-            if (currentRole.readonly) {
-                throw new ValidationError([{ field: 'name', reason: "role.readonly", value: payload.name }]);
-            }
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.DeleteRole);
-            const id = request.params.id;
-            const roleService = RoleServiceFactory();
-            const currentRole = await roleService.findById(id);
-            if (currentRole.readonly) {
-                throw new UnauthorizedError();
-            }
-            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' });
-            }
-        }
-    });
+    const controller = new RoleController();
+    fastify.get('/api/permissions', (req, rep) => controller.permissions(req, rep));
+    fastify.get('/api/roles/search', (req, rep) => controller.search(req, rep));
+    fastify.get('/api/roles/:id', (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/roles/name/:name', (req, rep) => controller.findByName(req, rep));
+    fastify.get('/api/roles/all', (req, rep) => controller.all(req, rep));
+    fastify.get('/api/roles', (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/roles', (req, rep) => controller.create(req, rep));
+    fastify.put('/api/roles/:id', (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/roles/:id', (req, rep) => controller.delete(req, rep));
 }
 export default RoleRoutes;
 export { RoleRoutes };

package/dist/routes/TenantRoutes.js

@@ -2,6 +2,7 @@ import TenantController from '../controllers/TenantController.js';
 async function TenantRoutes(fastify, options) {
     const controller = new TenantController();
     fastify.get('/api/tenants/export', (req, rep) => controller.export(req, rep));
+    fastify.get('/api/tenants/search', (req, rep) => controller.search(req, rep));
     fastify.get('/api/tenants/:id', (req, rep) => controller.findById(req, rep));
     fastify.get('/api/tenants/name/:name', (req, rep) => controller.findByName(req, rep));
     fastify.get('/api/tenants/all', (req, rep) => controller.all(req, rep));

package/dist/routes/UserApiKeyRoutes.js

@@ -1,118 +1,10 @@
-import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
-import { ValidationError, UnauthorizedError } from "@drax/common-back";
-import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
+import UserApiKeyController from "../controllers/UserApiKeyController.js";
 async function UserApiKeyRoutes(fastify, options) {
-    fastify.get('/api/user-api-keys', async (request, reply) => {
-        try {
-            request.rbac.assertAuthenticated();
-            request.rbac.assertOrPermissions([
-                IdentityPermissions.ViewUserApiKey,
-                IdentityPermissions.ViewMyUserApiKey
-            ]);
-            const filters = [];
-            if (!request.rbac.hasPermission(IdentityPermissions.ViewUserApiKey)) {
-                filters.push({ field: "user", operator: "eq", value: request.rbac.authUser.id });
-            }
-            const page = request.query.page;
-            const limit = request.query.limit;
-            const orderBy = request.query.orderBy;
-            const order = request.query.order;
-            const search = request.query.search;
-            const userApiKeyService = UserApiKeyServiceFactory();
-            let paginateResult = await userApiKeyService.paginate({ page, limit, orderBy, order, search, filters });
-            return paginateResult;
-        }
-        catch (e) {
-            console.log("/api/user-api-keys", 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/user-api-keys', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.CreateUserApiKey);
-            const payload = request.body;
-            payload.user = request.rbac.authUser.id;
-            const userApiKeyService = UserApiKeyServiceFactory();
-            let userApiKey = await userApiKeyService.create(payload);
-            return userApiKey;
-        }
-        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/user-api-keys/:id', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.UpdateUserApiKey);
-            const id = request.params.id;
-            const payload = request.body;
-            const userApiKeyService = UserApiKeyServiceFactory();
-            let userApiKey = await userApiKeyService.update(id, payload);
-            return userApiKey;
-        }
-        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/user-api-keys/:id', async (request, reply) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.DeleteUserApiKey);
-            const id = request.params.id;
-            const userApiKeyService = UserApiKeyServiceFactory();
-            let r = await userApiKeyService.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' });
-            }
-        }
-    });
+    const controller = new UserApiKeyController();
+    fastify.get('/api/user-api-keys', (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/user-api-keys', (req, rep) => controller.create(req, rep));
+    fastify.put('/api/user-api-keys/:id', (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/user-api-keys/:id', (req, rep) => controller.delete(req, rep));
 }
 export default UserApiKeyRoutes;
 export { UserApiKeyRoutes };

package/dist/routes/UserRoutes.js

@@ -1,222 +1,16 @@
-import UserServiceFactory from "../factory/UserServiceFactory.js";
-import { ValidationError, UnauthorizedError } from "@drax/common-back";
-import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
-import BadCredentialsError from "../errors/BadCredentialsError.js";
+import UserController from "../controllers/UserController.js";
 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);
-            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) => {
-        try {
-            if (request.authUser) {
-                const userService = UserServiceFactory();
-                let user = await userService.findById(request.authUser.id);
-                user.password = undefined;
-                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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewUser);
-            const page = request.query.page;
-            const limit = request.query.limit;
-            const orderBy = request.query.orderBy;
-            const order = request.query.order;
-            const search = request.query.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, orderBy, order, search, filters });
-            for (let item of paginateResult.items) {
-                item.password = undefined;
-                delete item.password;
-            }
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.CreateUser);
-            const payload = request.body;
-            const userService = UserServiceFactory();
-            if (request.rbac.getAuthUser.tenantId) {
-                payload.tenant = request.rbac.getAuthUser.tenantId;
-            }
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.UpdateUser);
-            const id = request.params.id;
-            const payload = request.body;
-            const userService = UserServiceFactory();
-            if (request.rbac.getAuthUser.tenantId) {
-                payload.tenant = request.rbac.getAuthUser.tenantId;
-            }
-            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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.DeleteUser);
-            const id = request.params.id;
-            const userService = UserServiceFactory();
-            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;
-            const userService = UserServiceFactory();
-            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;
-            const userService = UserServiceFactory();
-            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' });
-            }
-        }
-    });
+    const controller = new UserController();
+    fastify.post('/api/auth', (req, rep) => controller.auth(req, rep));
+    fastify.get('/api/me', (req, rep) => controller.me(req, rep));
+    fastify.get('/api/users', (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/users', (req, rep) => controller.create(req, rep));
+    fastify.put('/api/users/:id', (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/users/:id', (req, rep) => controller.delete(req, rep));
+    fastify.post('/api/password', (req, rep) => controller.myPassword(req, rep));
+    fastify.post('/api/password/:id', (req, rep) => controller.password(req, rep));
+    fastify.post('/api/user/avatar', (req, rep) => controller.updateAvatar(req, rep));
+    fastify.get('/api/user/avatar/:filename', (req, rep) => controller.getAvatar(req, rep));
 }
 export default UserRoutes;
 export { UserRoutes };

package/dist/services/RoleService.js

@@ -1,8 +1,10 @@
-import { ZodErrorToValidationError } from "@drax/common-back";
+import { UnauthorizedError, ValidationError, ZodErrorToValidationError } from "@drax/common-back";
+import { AbstractService } from "@drax/crud-back";
 import { roleSchema } from "../zod/RoleZod.js";
 import { ZodError } from "zod";
-class RoleService {
+class RoleService extends AbstractService {
     constructor(roleRepostitory) {
+        super(roleRepostitory, roleSchema);
         this._repository = roleRepostitory;
         console.log("RoleService constructor");
     }
@@ -25,6 +27,10 @@ class RoleService {
         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;
         }
@@ -36,7 +42,36 @@ class RoleService {
             throw e;
         }
     }
+    async systemUpdate(id, roleData) {
+        try {
+            roleData.name = roleData?.name?.trim();
+            await roleSchema.parseAsync(roleData);
+            const role = await this._repository.update(id, roleData);
+            return role;
+        }
+        catch (e) {
+            console.error("Error systemUpdating role", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, roleData);
+            }
+            throw e;
+        }
+    }
     async delete(id) {
+        try {
+            const currentRole = await this.findById(id);
+            if (currentRole.readonly) {
+                throw new UnauthorizedError();
+            }
+            const deletedRole = await this._repository.delete(id);
+            return deletedRole;
+        }
+        catch (e) {
+            console.error("Error deleting role", e);
+            throw e;
+        }
+    }
+    async systemDelete(id) {
         try {
             const deletedRole = await this._repository.delete(id);
             return deletedRole;
@@ -70,6 +105,11 @@ class RoleService {
         const roles = await this._repository.fetchAll();
         return roles;
     }
+    async search(value) {
+        const limit = 100;
+        const roles = await this._repository.search(value, limit);
+        return roles;
+    }
     async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
         try {
             const pagination = await this._repository.paginate({ page, limit, orderBy, order, search, filters });

package/dist/services/TenantService.js

@@ -78,6 +78,11 @@ class TenantService extends AbstractService {
             throw e;
         }
     }
+    async search(value) {
+        const limit = 100;
+        const tenants = await this._repository.search(value, limit);
+        return tenants;
+    }
     async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
         try {
             const pagination = await this._repository.paginate({ page, limit, orderBy, order, search, filters });