@drax/identity-back 0.4.0 → 0.5.2

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";

package/src/index.ts

@@ -21,9 +21,7 @@ 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";
@@ -38,6 +36,14 @@ import type {IUserRepository} from "./interfaces/IUserRepository";
 import type {IUserApiKeyRepository} from "./interfaces/IUserApiKeyRepository";
 
 
+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;
@@ -83,12 +89,15 @@ export {
 
     //Permissions
     IdentityPermissions,
+    RolePermissions,
+    TenantPermissions,
+    UserPermissions,
+    UserApiKeyPermissions,
 
     //Config
     IdentityConfig,
 
     //Errors
-    UnauthorizedError,
     BadCredentialsError,
 
     //Setup

package/src/interfaces/IRoleRepository.ts

@@ -1,5 +1,5 @@
 import {IRole, IRoleBase} from "@drax/identity-share";
-import {IDraxCrud} from "@drax/common-share";
+import {IDraxCrud} from "@drax/crud-share";
 
 interface IRoleRepository extends IDraxCrud<IRole, IRoleBase, IRoleBase> {
     findById(id: string): Promise<IRole | null>;

package/src/interfaces/ITenantRepository.ts

@@ -1,5 +1,5 @@
 import {ITenant, ITenantBase} from '@drax/identity-share'
-import {IDraxCrud} from "@drax/common-share";
+import {IDraxCrud} from "@drax/crud-share";
 interface ITenantRepository extends IDraxCrud<ITenant,ITenantBase,ITenantBase>{
     findById(id: string): Promise<ITenant | null>;
     findByName(name: string): Promise<ITenant | null>;

package/src/interfaces/IUserApiKeyRepository.ts

@@ -1,5 +1,5 @@
 import {IUserApiKey, IUserApiKeyBase} from '@drax/identity-share'
-import {IDraxCrud} from "@drax/common-share";
+import {IDraxCrud} from "@drax/crud-share";
 
 interface IUserApiKeyRepository extends IDraxCrud<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase>{
     findBySecret(username: string): Promise<IUserApiKey | null>;

package/src/interfaces/IUserRepository.ts

@@ -1,5 +1,5 @@
 import {IUser, IUserCreate, IUserUpdate} from '@drax/identity-share'
-import {IDraxCrud} from "@drax/common-share";
+import {IDraxCrud} from "@drax/crud-share";
 
 interface IUserRepository extends IDraxCrud<IUser, IUserCreate, IUserUpdate>{
     findById(id: string): Promise<IUser | null>;

package/src/permissions/IdentityPermissions.ts

@@ -1,3 +1,4 @@
+
 enum IdentityPermissions {
 
 

package/src/permissions/RolePermissions.ts

@@ -0,0 +1,12 @@
+enum RolePermissions {
+    Create = "role:create",
+    Update = "role:update",
+    Delete = "role:delete",
+    View = "role:view",
+    Manage = "role:manage",
+    Permissions = "role:permissions",
+
+}
+
+export default RolePermissions;
+export {RolePermissions};

package/src/permissions/TenantPermissions.ts

@@ -0,0 +1,11 @@
+enum TenantPermissions {
+    Create = "tenant:create",
+    Update = "tenant:update",
+    Delete= "tenant:delete",
+    View = "tenant:view",
+    Manage = "tenant:manage",
+
+}
+
+export default TenantPermissions;
+export {TenantPermissions};

package/src/permissions/UserApiKeyPermissions.ts

@@ -0,0 +1,12 @@
+enum UserApiKeyPermissions {
+    Create = "userApiKey:create",
+    Update = "userApiKey:update",
+    Delete = "userApiKey:delete",
+    View = "userApiKey:view",
+    ViewMy = "userApiKey:myView",
+    Manage = "userApiKey:manage",
+
+}
+
+export default UserApiKeyPermissions;
+export {UserApiKeyPermissions};

package/src/permissions/UserPermissions.ts

@@ -0,0 +1,11 @@
+enum UserPermissions {
+    Create = "user:create",
+    Update = "user:update",
+    Delete = "user:delete",
+    View = "user:view",
+    Manage = "user:manage",
+
+}
+
+export default UserPermissions;
+export {UserPermissions};

package/src/permissions/index.ts

@@ -0,0 +1,15 @@
+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/src/rbac/Rbac.ts

@@ -1,5 +1,5 @@
 import {IJwtUser, IRole} from "@drax/identity-share";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {UnauthorizedError} from "@drax/common-back";
 
 class Rbac {
     private role: IRole;

package/src/repository/mongo/RoleMongoRepository.ts

@@ -3,7 +3,7 @@ import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {mongoose, MongooseQueryFilter, MongooseSort} from "@drax/common-back";
 import {PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {IRoleBase, IRole} from "@drax/identity-share";
 
 class RoleMongoRepository implements IRoleRepository{

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,55 +1,56 @@
 import {TenantModel} from "../../models/TenantModel.js";
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {mongoose, MongooseSort, MongooseQueryFilter} from "@drax/common-back";
-import { PaginateOptions, PaginateResult} from "mongoose";
+import {PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {ITenant, ITenantBase} from "@drax/identity-share";
 
-class TenantMongoRepository implements ITenantRepository{
+class TenantMongoRepository implements ITenantRepository {
 
     async create(tenantData: ITenantBase): Promise<ITenant> {
-        const tenant : mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
+        const tenant: mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
         await tenant.save()
         return tenant
     }
 
     async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
-        const tenant : mongoose.HydratedDocument<ITenant> = await TenantModel.findOneAndUpdate({_id: id}, tenantData, {new: true}).exec()
+        const tenant: mongoose.HydratedDocument<ITenant> = await TenantModel.findOneAndUpdate({_id: id}, tenantData, {new: true}).exec()
         return tenant
     }
 
     async delete(id: string): Promise<boolean> {
-        const result : DeleteResult = await TenantModel.deleteOne({_id:id}).exec()
+        const result: DeleteResult = await TenantModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: string): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null> {
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findById(id).exec()
         return tenant
     }
 
-    async findByName(name: string): Promise<ITenant | null>{
+    async findByName(name: string): Promise<ITenant | null> {
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findOne({name}).exec()
         return tenant
     }
 
-    async fetchAll(): Promise<ITenant[]>{
+    async fetchAll(): Promise<ITenant[]> {
         const tenants: mongoose.HydratedDocument<ITenant>[] = await TenantModel.find().exec()
         return tenants
     }
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
 
         const query = {}
 
-        if(search){
+        if (search) {
             query['$or'] = [
                 {name: new RegExp(search, 'i')},
             ]
@@ -68,6 +69,30 @@ class TenantMongoRepository implements ITenantRepository{
             items: tenants.docs
         }
     }
+
+    async find({
+                   cursor = false,
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<ITenant[]> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+        const items: ITenant[] = await TenantModel.find(query).sort(sort)
+        return items
+    }
 }
 
 export default TenantMongoRepository

package/src/repository/mongo/UserApiKeyMongoRepository.ts

@@ -8,7 +8,7 @@ import {
 import type {IUserApiKey, IUserApiKeyBase, IUserApiKeySoftDelete} from "@drax/identity-share";
 import {DeleteResult, MongoServerError} from "mongodb";
 import {PaginateResult} from "mongoose";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {IUserApiKeyRepository} from "../../interfaces/IUserApiKeyRepository";
 
 class UserMongoRepository implements IUserApiKeyRepository {

package/src/repository/mongo/UserMongoRepository.ts

@@ -11,7 +11,7 @@ import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
 import {PaginateResult} from "mongoose";
 import RoleMongoRepository from "./RoleMongoRepository.js";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 
 class UserMongoRepository implements IUserRepository {
     private roleRepository: RoleMongoRepository;

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -2,7 +2,7 @@ import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
 import {IRole, IRoleBase} from "@drax/identity-share";
 import {
     SqliteErrorToValidationError,

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -3,7 +3,7 @@ import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IDraxPaginateResult, IDraxPaginateOptions, IDraxFindOptions} from "@drax/crud-share";
 import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 
@@ -143,6 +143,29 @@ class TenantSqliteRepository implements ITenantRepository{
         }
     }
 
+    async find({
+                   cursor = false,
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<ITenant[]>{
+
+        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
+    }
+
 
 }
 

package/src/repository/sqlite/UserApiKeySqliteRepository.ts

@@ -3,7 +3,7 @@ import {IUserApiKeyRepository} from '../../interfaces/IUserApiKeyRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
 import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 import UserSqliteRepository from "./UserSqliteRepository.js";

package/src/repository/sqlite/UserSqliteRepository.ts

@@ -3,7 +3,7 @@ import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
 import {
     SqliteErrorToValidationError,
     SqliteTableBuilder,

package/src/routes/RoleRoutes.ts

@@ -1,10 +1,9 @@
-import { ValidationError} from "@drax/common-back";
+import { ValidationError, UnauthorizedError} from "@drax/common-back";
 import RoleServiceFactory from "../factory/RoleServiceFactory.js";
 import {IRole} from "@drax/identity-share";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
 import {PermissionService} from "../services/PermissionService.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
-import {IDraxPaginateResult} from "@drax/common-share";
+import {IDraxPaginateResult} from "@drax/crud-share";
 
 
 

package/src/routes/TenantRoutes.ts

@@ -1,178 +1,24 @@
-import { ValidationError} from "@drax/common-back";
-import TenantServiceFactory from "../factory/TenantServiceFactory.js";
-import {ITenant} from "@drax/identity-share";
-import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
-import {IDraxPaginateResult} from "@drax/common-share";
-
-
+import TenantController from '../controllers/TenantController.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'})
-            }
-        }
-    })
+    const controller: TenantController = new TenantController()
 
-    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/export', (req,rep) => controller.export(req,rep) )
 
-    fastify.get('/api/tenants', async (request, reply): Promise<IDraxPaginateResult<ITenant>> => {
-        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.get('/api/tenants/:id', (req,rep) => controller.findById(req,rep) )
 
-    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.get('/api/tenants/name/:name', (req,rep) => controller.findByName(req,rep))
 
-    })
+    fastify.get('/api/tenants/all', (req,rep) => controller.all(req,rep))
 
-    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()
+    fastify.get('/api/tenants', (req,rep) => controller.paginate(req,rep))
 
-            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.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', 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'})
-            }
-        }
-    })
+    fastify.delete('/api/tenants/:id', (req,rep) => controller.delete(req,rep))
 
 }
 

package/src/routes/UserApiKeyRoutes.ts

@@ -1,9 +1,8 @@
 import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
 import type {IUserApiKey} from "@drax/identity-share";
-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 {IDraxPaginateResult} from "@drax/common-share";
+import {IDraxPaginateResult} from "@drax/crud-share";
 
 
 async function UserApiKeyRoutes(fastify, options) {