@drax/identity-back 0.5.3 → 0.5.5

package/src/repository/mongo/RoleMongoRepository.ts

@@ -1,58 +1,68 @@
 import {RoleModel} from "../../models/RoleModel.js";
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {mongoose, MongooseQueryFilter, MongooseSort} from "@drax/common-back";
-import {PaginateOptions, PaginateResult} from "mongoose";
+import {Cursor, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {IRoleBase, IRole} from "@drax/identity-share";
 
-class RoleMongoRepository implements IRoleRepository{
+class RoleMongoRepository implements IRoleRepository {
+
+    _searchFields = ['name']
 
     async create(roleData: IRoleBase): Promise<IRole> {
-        const role : mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
+        const role: mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
         await role.save()
         await role.populate('childRoles')
         return role
     }
 
     async update(id: string, roleData: IRoleBase): Promise<IRole> {
-        const role : mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate({_id: id}, roleData, {new: true}).populate('childRoles').exec()
+        const role: mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate({_id: id}, roleData, {new: true}).populate('childRoles').exec()
         return role
     }
 
     async delete(id: string): Promise<boolean> {
-        const result : DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
+        const result: DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: string): Promise<IRole | null>{
+    async findById(id: string): Promise<IRole | null> {
         const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findById(id).populate('childRoles').exec()
         return role
     }
 
-    async findByName(name: string): Promise<IRole | null>{
+    async findByName(name: string): Promise<IRole | null> {
         const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findOne({name}).populate('childRoles').exec()
         return role
     }
 
-    async fetchAll(): Promise<IRole[]>{
+    async fetchAll(): Promise<IRole[]> {
         const roles: mongoose.HydratedDocument<IRole>[] = await RoleModel.find().populate('childRoles').exec()
         return roles
     }
 
+    async search(value: string, limit: number = 1000): Promise<IRole[]> {
+        const query = {}
+        if (value) {
+            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
+        }
+        const items: mongoose.HydratedDocument<IRole>[] = await RoleModel.find(query).limit(limit).exec()
+        return items
+    }
+
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         const query = {}
 
-        if(search){
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if (search) {
+            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
         }
 
         MongooseQueryFilter.applyFilters(query, filters)
@@ -68,6 +78,52 @@ class RoleMongoRepository implements IRoleRepository{
             items: roles.docs
         }
     }
+
+    async find({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<IRole[]> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return await RoleModel.find(query).limit(limit).sort(sort)
+    }
+
+    async findCursor({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<Cursor> {
+        console.log("RoleMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return RoleModel.find(query).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default RoleMongoRepository

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,13 +1,15 @@
 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 {Cursor, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
 import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {ITenant, ITenantBase} from "@drax/identity-share";
 
 class TenantMongoRepository implements ITenantRepository {
 
+    _searchFields = ['_id','name']
+
     async create(tenantData: ITenantBase): Promise<ITenant> {
         const tenant: mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
         await tenant.save()
@@ -39,6 +41,15 @@ class TenantMongoRepository implements ITenantRepository {
         return tenants
     }
 
+    async search(value: string, limit: number = 1000): Promise<ITenant[]> {
+        const query = {}
+        if(value){
+            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
+        }
+        const items: mongoose.HydratedDocument<ITenant>[] = await TenantModel.find(query).limit(limit).exec()
+        return items
+    }
+
     async paginate({
                        page = 1,
                        limit = 5,
@@ -71,7 +82,6 @@ class TenantMongoRepository implements ITenantRepository {
     }
 
     async find({
-                   cursor = false,
                    limit = 0,
                    orderBy = '',
                    order = false,
@@ -90,9 +100,32 @@ class TenantMongoRepository implements ITenantRepository {
         MongooseQueryFilter.applyFilters(query, filters)
 
         const sort = MongooseSort.applySort(orderBy, order)
-        const items: ITenant[] = await TenantModel.find(query).sort(sort)
+        const items: ITenant[] = await TenantModel.find(query).limit(limit).sort(sort)
         return items
     }
+
+    async findCursor({
+                         limit = 0,
+                         orderBy = '',
+                         order = false,
+                         search = '',
+                         filters = []
+                     }: IDraxFindOptions): Promise<Cursor> {
+        console.log("TenantMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return TenantModel.find(query).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default TenantMongoRepository

package/src/repository/mongo/UserMongoRepository.ts

@@ -9,9 +9,10 @@ import {
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
-import {PaginateResult} from "mongoose";
+import {Cursor, PaginateResult} from "mongoose";
 import RoleMongoRepository from "./RoleMongoRepository.js";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IRole} from "@drax/identity-share";
 
 class UserMongoRepository implements IUserRepository {
     private roleRepository: RoleMongoRepository;
@@ -124,6 +125,52 @@ class UserMongoRepository implements IUserRepository {
             return false
         }
     }
+
+    async find({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<IUser[]> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return await UserModel.find(query).populate(['role','tenant']).limit(limit).sort(sort)
+    }
+
+    async findCursor({
+                         limit = 0,
+                         orderBy = '',
+                         order = false,
+                         search = '',
+                         filters = []
+                     }: IDraxFindOptions): Promise<Cursor> {
+        console.log("RoleMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return UserModel.find(query).populate(['role','tenant']).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default UserMongoRepository

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -144,7 +144,6 @@ class TenantSqliteRepository implements ITenantRepository{
     }
 
     async find({
-                   cursor = false,
                    limit = 0,
                    orderBy = '',
                    order = false,

package/src/routes/RoleRoutes.ts

@@ -1,203 +1,30 @@
-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 {IDraxPaginateResult} from "@drax/crud-share";
+import RoleController from "../controllers/RoleController.js";
 
 
 
 async function RoleRoutes(fastify, options) {
 
-    fastify.get('/api/permissions', async (request, reply): Promise<string[]> => {
-        try {
-            request.rbac.assertPermission(IdentityPermissions.PermissionsRole)
-            let permissions = PermissionService.getPermissions()
-            return permissions
-        }catch (e){
-            console.error(e)
-            if (e instanceof UnauthorizedError) {
-                reply.statusCode = e.statusCode
-                reply.send({error: e.message})
-            } else {
-                reply.statusCode = 500
-                reply.send({error: 'INTERNAL_SERVER_ERROR'})
-            }
-        }
-    })
-
-    fastify.get('/api/roles/:id', async (request, reply): Promise<IRole> => {
-        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): Promise<IRole> => {
-        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): Promise<IRole[]> => {
-        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): Promise<IDraxPaginateResult<IRole>> => {
-        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): Promise<IRole> => {
-        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): Promise<IRole> => {
-        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): Promise<any> => {
-        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: RoleController = new RoleController()
+
+    fastify.get('/api/permissions', (req,rep) => controller.permissions(req,rep))
+
+    fastify.get('/api/roles/export', (req,rep) => controller.export(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))
 
 }
 

package/src/routes/TenantRoutes.ts

@@ -6,6 +6,8 @@ async function TenantRoutes(fastify, options) {
 
     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))

package/src/routes/UserApiKeyRoutes.ts

@@ -1,124 +1,17 @@
-import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
-import type {IUserApiKey} from "@drax/identity-share";
-import {ValidationError, UnauthorizedError} from "@drax/common-back";
-import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import {IDraxPaginateResult} from "@drax/crud-share";
+import UserApiKeyController from "../controllers/UserApiKeyController.js";
 
 
 async function UserApiKeyRoutes(fastify, options) {
 
-    fastify.get('/api/user-api-keys', async (request, reply): Promise<IDraxPaginateResult<IUserApiKey>> => {
+    const controller: UserApiKeyController = new UserApiKeyController()
 
-        try {
-            request.rbac.assertAuthenticated()
+    fastify.get('/api/user-api-keys', (req,rep) => controller.paginate(req,rep) )
 
-            request.rbac.assertOrPermissions([
-                IdentityPermissions.ViewUserApiKey,
-                IdentityPermissions.ViewMyUserApiKey
-            ])
+    fastify.post('/api/user-api-keys', (req,rep) => controller.create(req,rep))
 
-            const filters = []
+    fastify.put('/api/user-api-keys/:id', (req,rep) => controller.update(req,rep))
 
-            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): Promise<IUserApiKey> => {
-        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): Promise<IUserApiKey> => {
-        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): Promise<any> => {
-        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'})
-            }
-        }
-    })
+    fastify.delete('/api/user-api-keys/:id', (req,rep) => controller.delete(req,rep))
 
 
 }