@drax/identity-back 0.5.1 → 0.5.3

package/dist/controllers/TenantController.js

@@ -0,0 +1,66 @@
+import { AbstractFastifyController } from "@drax/crud-back";
+import { ValidationError } from "@drax/common-back";
+import TenantServiceFactory from "../factory/TenantServiceFactory.js";
+import TenantPermissions from "../permissions/TenantPermissions.js";
+import { UnauthorizedError } from "@drax/common-back";
+class TenantController extends AbstractFastifyController {
+    constructor() {
+        super(TenantServiceFactory(), TenantPermissions);
+    }
+    async findByName(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            if (!request.params.id) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const name = request.params.name;
+            let item = await this.service.findByName(name);
+            return item;
+        }
+        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' });
+            }
+        }
+    }
+    async all(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            let tenants = await this.service.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' });
+            }
+        }
+    }
+}
+export default TenantController;
+export { TenantController };

package/dist/graphql/resolvers/role.resolvers.js

@@ -1,9 +1,8 @@
 import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
 import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
-import { ValidationError, ValidationErrorToGraphQLError } from "@drax/common-back";
+import { ValidationError, ValidationErrorToGraphQLError, UnauthorizedError } from "@drax/common-back";
 import { GraphQLError } from "graphql";
 import { PermissionService } from "../../services/PermissionService.js";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 export default {
     Query: {
         findRoleById: async (_, { id }, { rbac }) => {

package/dist/graphql/resolvers/tenant.resolvers.js

@@ -1,8 +1,7 @@
 import TenantServiceFactory from "../../factory/TenantServiceFactory.js";
 import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
-import { ValidationError, ValidationErrorToGraphQLError } from "@drax/common-back";
+import { ValidationError, ValidationErrorToGraphQLError, UnauthorizedError } from "@drax/common-back";
 import { GraphQLError } from "graphql";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 export default {
     Query: {
         findTenantById: async (_, { id }, { rbac }) => {

package/dist/graphql/resolvers/user-api-key.resolvers.js

@@ -1,8 +1,7 @@
 import UserApiKeyServiceFactory from "../../factory/UserApiKeyServiceFactory.js";
 import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
-import { ValidationError, ValidationErrorToGraphQLError } from "@drax/common-back";
+import { ValidationError, ValidationErrorToGraphQLError, UnauthorizedError } from "@drax/common-back";
 import { GraphQLError } from "graphql";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 import * as crypto from "node:crypto";
 export default {
     Query: {

package/dist/graphql/resolvers/user.resolvers.js

@@ -2,7 +2,7 @@ import UserServiceFactory from "../../factory/UserServiceFactory.js";
 import { GraphQLError } from "graphql";
 import { ValidationErrorToGraphQLError, ValidationError, StoreManager, DraxConfig, CommonConfig } from "@drax/common-back";
 import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
+import { UnauthorizedError } from "@drax/common-back";
 import BadCredentialsError from "../../errors/BadCredentialsError.js";
 import { join } from "path";
 import IdentityConfig from "../../config/IdentityConfig.js";

package/dist/index.js

@@ -16,15 +16,18 @@ import AuthUtils from "./utils/AuthUtils.js";
 import { jwtMiddleware } from "./middleware/jwtMiddleware.js";
 import { rbacMiddleware } from "./middleware/rbacMiddleware.js";
 import { apiKeyMiddleware } from "./middleware/apiKeyMiddleware.js";
-import IdentityPermissions from "./permissions/IdentityPermissions.js";
 import IdentityConfig from "./config/IdentityConfig.js";
-import UnauthorizedError from "./errors/UnauthorizedError.js";
 import BadCredentialsError from "./errors/BadCredentialsError.js";
 import CreateUserIfNotExist from "./setup/CreateUserIfNotExist.js";
 import CreateOrUpdateRole from "./setup/CreateOrUpdateRole.js";
 import LoadPermissions from "./setup/LoadPermissions.js";
 import LoadIdentityConfigFromEnv from "./setup/LoadIdentityConfigFromEnv.js";
 import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
+import IdentityPermissions from "./permissions/IdentityPermissions.js";
+import { RolePermissions } from "./permissions/RolePermissions.js";
+import { TenantPermissions } from "./permissions/TenantPermissions.js";
+import { UserPermissions } from "./permissions/UserPermissions.js";
+import { UserApiKeyPermissions } from "./permissions/UserApiKeyPermissions.js";
 const graphqlMergeResult = await GraphqlMerge();
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
@@ -40,10 +43,10 @@ UserRoutes, RoleRoutes, TenantRoutes, UserAvatarRoutes, UserApiKeyRoutes, AuthUt
 //API MIDDLEWARE
 jwtMiddleware, rbacMiddleware, apiKeyMiddleware, 
 //Permissions
-IdentityPermissions, 
+IdentityPermissions, RolePermissions, TenantPermissions, UserPermissions, UserApiKeyPermissions, 
 //Config
 IdentityConfig, 
 //Errors
-UnauthorizedError, BadCredentialsError, 
+BadCredentialsError, 
 //Setup
 LoadIdentityConfigFromEnv, LoadPermissions, CreateOrUpdateRole, CreateUserIfNotExist, RecoveryUserPassword };

package/dist/permissions/RolePermissions.js

@@ -0,0 +1,11 @@
+var RolePermissions;
+(function (RolePermissions) {
+    RolePermissions["Create"] = "role:create";
+    RolePermissions["Update"] = "role:update";
+    RolePermissions["Delete"] = "role:delete";
+    RolePermissions["View"] = "role:view";
+    RolePermissions["Manage"] = "role:manage";
+    RolePermissions["Permissions"] = "role:permissions";
+})(RolePermissions || (RolePermissions = {}));
+export default RolePermissions;
+export { RolePermissions };

package/dist/permissions/TenantPermissions.js

@@ -0,0 +1,10 @@
+var TenantPermissions;
+(function (TenantPermissions) {
+    TenantPermissions["Create"] = "tenant:create";
+    TenantPermissions["Update"] = "tenant:update";
+    TenantPermissions["Delete"] = "tenant:delete";
+    TenantPermissions["View"] = "tenant:view";
+    TenantPermissions["Manage"] = "tenant:manage";
+})(TenantPermissions || (TenantPermissions = {}));
+export default TenantPermissions;
+export { TenantPermissions };

package/dist/permissions/UserApiKeyPermissions.js

@@ -0,0 +1,11 @@
+var UserApiKeyPermissions;
+(function (UserApiKeyPermissions) {
+    UserApiKeyPermissions["Create"] = "userApiKey:create";
+    UserApiKeyPermissions["Update"] = "userApiKey:update";
+    UserApiKeyPermissions["Delete"] = "userApiKey:delete";
+    UserApiKeyPermissions["View"] = "userApiKey:view";
+    UserApiKeyPermissions["ViewMy"] = "userApiKey:myView";
+    UserApiKeyPermissions["Manage"] = "userApiKey:manage";
+})(UserApiKeyPermissions || (UserApiKeyPermissions = {}));
+export default UserApiKeyPermissions;
+export { UserApiKeyPermissions };

package/dist/permissions/UserPermissions.js

@@ -0,0 +1,10 @@
+var UserPermissions;
+(function (UserPermissions) {
+    UserPermissions["Create"] = "user:create";
+    UserPermissions["Update"] = "user:update";
+    UserPermissions["Delete"] = "user:delete";
+    UserPermissions["View"] = "user:view";
+    UserPermissions["Manage"] = "user:manage";
+})(UserPermissions || (UserPermissions = {}));
+export default UserPermissions;
+export { UserPermissions };

package/dist/permissions/index.js

@@ -0,0 +1,12 @@
+import TenantPermissions from './TenantPermissions';
+import UserPermissions from './UserPermissions';
+import RolePermissions from './RolePermissions';
+import UserApiKeyPermissions from './UserApiKeyPermissions';
+const permissions = {
+    ...TenantPermissions,
+    ...UserPermissions,
+    ...RolePermissions,
+    ...UserApiKeyPermissions
+};
+export default permissions;
+export { permissions };

package/dist/rbac/Rbac.js

@@ -1,4 +1,4 @@
-import UnauthorizedError from "../errors/UnauthorizedError.js";
+import { UnauthorizedError } from "@drax/common-back";
 class Rbac {
     constructor(authUser, role) {
         this.authUser = authUser;

package/dist/repository/mongo/TenantMongoRepository.js

@@ -44,5 +44,17 @@ class TenantMongoRepository {
             items: tenants.docs
         };
     }
+    async find({ cursor = false, limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        const items = await TenantModel.find(query).sort(sort);
+        return items;
+    }
 }
 export default TenantMongoRepository;

package/dist/repository/sqlite/TenantSqliteRepository.js

@@ -96,5 +96,16 @@ class TenantSqliteRepository {
             items: tenants
         };
     }
+    async find({ cursor = false, limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        let where = "";
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`;
+        }
+        where = SqlQueryFilter.applyFilters(where, filters);
+        const sort = SqlSort.applySort(orderBy, order);
+        where += sort;
+        const tenants = this.db.prepare('SELECT * FROM tenants ' + where).all();
+        return tenants;
+    }
 }
 export default TenantSqliteRepository;

package/dist/routes/RoleRoutes.js

@@ -1,8 +1,7 @@
-import { ValidationError } from "@drax/common-back";
+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 UnauthorizedError from "../errors/UnauthorizedError.js";
 async function RoleRoutes(fastify, options) {
     fastify.get('/api/permissions', async (request, reply) => {
         try {

package/dist/routes/TenantRoutes.js

@@ -1,185 +1,14 @@
-import { ValidationError } from "@drax/common-back";
-import TenantServiceFactory from "../factory/TenantServiceFactory.js";
-import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
+import TenantController from '../controllers/TenantController.js';
 async function TenantRoutes(fastify, options) {
-    fastify.get('/api/tenants/:id', async (request, reply) => {
-        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) => {
-        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) => {
-        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) => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.ViewTenant);
-            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 tenantService = TenantServiceFactory();
-            let paginateResult = await tenantService.paginate({ page, limit, orderBy, order, 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) => {
-        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) => {
-        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) => {
-        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' });
-            }
-        }
-    });
+    const controller = new TenantController();
+    fastify.get('/api/tenants/export', (req, rep) => controller.export(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));
+    fastify.get('/api/tenants', (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/tenants', (req, rep) => controller.create(req, rep));
+    fastify.put('/api/tenants/:id', (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/tenants/:id', (req, rep) => controller.delete(req, rep));
 }
 export default TenantRoutes;
 export { TenantRoutes };

package/dist/routes/UserApiKeyRoutes.js

@@ -1,7 +1,6 @@
 import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
-import { ValidationError } from "@drax/common-back";
+import { ValidationError, UnauthorizedError } from "@drax/common-back";
 import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
 async function UserApiKeyRoutes(fastify, options) {
     fastify.get('/api/user-api-keys', async (request, reply) => {
         try {

package/dist/routes/UserAvatarRoutes.js

@@ -1,6 +1,5 @@
 import { join } from "path";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
-import { StoreManager, UploadFileError, DraxConfig, CommonConfig } from "@drax/common-back";
+import { StoreManager, UploadFileError, DraxConfig, CommonConfig, UnauthorizedError } from "@drax/common-back";
 import UserServiceFactory from "../factory/UserServiceFactory.js";
 import IdentityConfig from "../config/IdentityConfig.js";
 const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';

package/dist/routes/UserRoutes.js

@@ -1,7 +1,6 @@
 import UserServiceFactory from "../factory/UserServiceFactory.js";
-import { ValidationError } from "@drax/common-back";
+import { ValidationError, UnauthorizedError } from "@drax/common-back";
 import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 async function UserRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {

package/dist/services/TenantService.js

@@ -1,8 +1,10 @@
 import { ZodErrorToValidationError } from "@drax/common-back";
 import { tenantSchema } from "../zod/TenantZod.js";
 import { ZodError } from "zod";
-class TenantService {
+import { AbstractService } from "@drax/crud-back";
+class TenantService extends AbstractService {
     constructor(tenantRepostitory) {
+        super(tenantRepostitory, tenantSchema);
         this._repository = tenantRepostitory;
         console.log("TenantService constructor");
     }

package/package.json

@@ -3,10 +3,10 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
-  "types": "types/index.d.ts",
+  "types": "dist/types/index.d.ts",
   "type": "module",
   "scripts": {
     "prepublish": "tsc && npm run copygql",
@@ -28,8 +28,9 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.5.1",
-    "@drax/crud-share": "^0.5.1",
+    "@drax/common-back": "^0.5.3",
+    "@drax/crud-back": "^0.5.3",
+    "@drax/crud-share": "^0.5.3",
     "@drax/identity-share": "^0.5.1",
     "bcryptjs": "^2.4.3",
     "express-jwt": "^8.4.1",
@@ -61,5 +62,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "6f507c8b52e134f10839fd7698c2466ff65a3d08"
+  "gitHead": "56ea5a743bce196d6322ae6c26ea5b041450d7a3"
 }

package/src/controllers/TenantController.ts

@@ -0,0 +1,73 @@
+import type {ITenant, ITenantBase} from "@drax/identity-share";
+import {AbstractFastifyController} from "@drax/crud-back";
+import {ValidationError} from "@drax/common-back";
+
+import TenantServiceFactory from "../factory/TenantServiceFactory.js";
+import TenantService from "../services/TenantService.js";
+import TenantPermissions from "../permissions/TenantPermissions.js";
+import {UnauthorizedError} from "@drax/common-back";
+
+class TenantController extends AbstractFastifyController<ITenant, ITenantBase, ITenantBase>   {
+
+    protected service: TenantService
+
+    constructor() {
+        super(TenantServiceFactory(), TenantPermissions)
+    }
+
+    async findByName(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            if(!request.params.id){
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+            const name = request.params.name
+            let item = await this.service.findByName(name)
+            return item
+        } 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'})
+            }
+        }
+    }
+
+    async all(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            let tenants = await this.service.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'})
+            }
+        }
+    }
+
+}
+
+export default TenantController;
+export {
+    TenantController
+}
+

package/src/graphql/resolvers/role.resolvers.ts

@@ -1,9 +1,8 @@
 import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
 import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
-import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
+import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
 import {PermissionService} from "../../services/PermissionService.js";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 
 
 export default {

package/src/graphql/resolvers/tenant.resolvers.ts

@@ -1,8 +1,7 @@
 import TenantServiceFactory from "../../factory/TenantServiceFactory.js";
 import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
-import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
+import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 
 
 export default {

package/src/graphql/resolvers/user-api-key.resolvers.ts

@@ -1,8 +1,7 @@
 import UserApiKeyServiceFactory from "../../factory/UserApiKeyServiceFactory.js";
 import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
-import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
+import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
 import * as crypto from "node:crypto";
 
 

package/src/graphql/resolvers/user.resolvers.ts

@@ -8,7 +8,7 @@ import {
     CommonConfig
 } from "@drax/common-back";
 import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../../errors/UnauthorizedError.js";
+import {UnauthorizedError} from "@drax/common-back";
 import BadCredentialsError from "../../errors/BadCredentialsError.js";
 import {join} from "path";
 import IdentityConfig from "../../config/IdentityConfig.js";