@drax/identity-back 0.11.5 → 0.12.2

package/src/models/RoleModel.ts

@@ -6,7 +6,7 @@ const Schema = mongoose.Schema
 import {PaginateModel} from "mongoose";
 
 
-const RoleSchema = new Schema<IRole>({
+const RoleMongoSchema = new Schema<IRole>({
     name: {
         type: String, unique: true, required: true, index: true,
     },
@@ -17,21 +17,26 @@ const RoleSchema = new Schema<IRole>({
         required: false,
     }],
     readonly: {type: Boolean, required: false, default: false},
+}, {timestamps: true, toJSON: {  virtuals: true}, toObject: {virtuals: true} } );
+
+RoleMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
 });
 
-RoleSchema.plugin(uniqueValidator, {message: 'validation.unique'});
-RoleSchema.plugin(MongooseSoftDelete);
-RoleSchema.plugin(mongoosePaginate);
+
+RoleMongoSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+RoleMongoSchema.plugin(MongooseSoftDelete);
+RoleMongoSchema.plugin(mongoosePaginate);
 
 
-RoleSchema.set('toJSON', {getters: true});
+RoleMongoSchema.set('toJSON', {getters: true, virtuals: true});
 
 const ROLE_MODEL_NAME = 'Role';
 const ROLE_COLLECTION_NAME = 'roles';
-const RoleModel = mongoose.model<IRole, PaginateModel<IRole>>(ROLE_MODEL_NAME, RoleSchema,ROLE_COLLECTION_NAME);
+const RoleModel = mongoose.models.Role as mongoose.Model<IRole> & PaginateModel<IRole> ||  mongoose.model<IRole, PaginateModel<IRole>>(ROLE_MODEL_NAME, RoleMongoSchema,ROLE_COLLECTION_NAME);
 
 export {
-    RoleSchema,
+    RoleMongoSchema,
     RoleModel
 }
 

package/src/models/TenantModel.ts

@@ -6,23 +6,28 @@ const Schema = mongoose.Schema
 import {PaginateModel} from "mongoose";
 
 
-const TenantSchema = new Schema<ITenant>({
+const TenantMongoSchema = new Schema<ITenant>({
     name: {type: String, unique: true, required: true, index: true,},
-}, {timestamps: true});
+}, {timestamps: true, toJSON: {  virtuals: true}, toObject: { virtuals: true}});
 
-TenantSchema.plugin(uniqueValidator, {message: 'validation.unique'});
-TenantSchema.plugin(MongooseSoftDelete);
-TenantSchema.plugin(mongoosePaginate);
 
+TenantMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
 
-TenantSchema.set('toJSON', {getters: true});
+TenantMongoSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+TenantMongoSchema.plugin(MongooseSoftDelete);
+TenantMongoSchema.plugin(mongoosePaginate);
+
+
+TenantMongoSchema.set('toJSON', {getters: true, virtuals: true});
 
 const TENANT_MODEL_NAME = 'Tenant';
 const TENANT_COLLECTION_NAME = 'tenants';
-const TenantModel = mongoose.model<ITenant, PaginateModel<ITenant>>(TENANT_MODEL_NAME, TenantSchema,TENANT_COLLECTION_NAME);
+const TenantModel = mongoose.models.Tenant as mongoose.Model<ITenant> & PaginateModel<ITenant> || mongoose.model<ITenant, PaginateModel<ITenant>>(TENANT_MODEL_NAME, TenantMongoSchema,TENANT_COLLECTION_NAME);
 
 export {
-    TenantSchema,
+    TenantMongoSchema,
     TenantModel
 }
 

package/src/models/UserApiKeyModel.ts

@@ -5,7 +5,7 @@ import mongoosePaginate from 'mongoose-paginate-v2'
 import {PaginateModel} from "mongoose";
 
 // Defining user Mongoose Schema
-const UserApiKeySchema = new mongoose.Schema<IUserApiKey>({
+const UserApiKeyMongoSchema = new mongoose.Schema<IUserApiKey>({
     name: {
         type: String,
         unique: false,
@@ -42,21 +42,26 @@ const UserApiKeySchema = new mongoose.Schema<IUserApiKey>({
     },
 }, {timestamps: true});
 
-UserApiKeySchema.set('toJSON', {getters: true});
+UserApiKeyMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
 
-UserApiKeySchema.plugin(uniqueValidator, {message: 'validation.unique'});
 
-UserApiKeySchema.plugin(MongooseSoftDelete);
-UserApiKeySchema.plugin(mongoosePaginate);
+UserApiKeyMongoSchema.set('toJSON', {getters: true, virtuals: true});
+
+UserApiKeyMongoSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+
+UserApiKeyMongoSchema.plugin(MongooseSoftDelete);
+UserApiKeyMongoSchema.plugin(mongoosePaginate);
 
 const MODEL_NAME = 'UserApiKey';
 const COLLECTION_NAME = 'userApiKeys';
 
-const UserApiKeyModel = mongoose.model<IUserApiKey,PaginateModel<IUserApiKey>>(MODEL_NAME, UserApiKeySchema,COLLECTION_NAME);
+const UserApiKeyModel = mongoose.models.UserApiKey as mongoose.Model<IUserApiKey> & PaginateModel<IUserApiKey> ||  mongoose.model<IUserApiKey,PaginateModel<IUserApiKey>>(MODEL_NAME, UserApiKeyMongoSchema,COLLECTION_NAME);
 
 
 export {
-    UserApiKeySchema,
+    UserApiKeyMongoSchema,
     UserApiKeyModel
 }
 

package/src/models/UserGroupModel.ts

@@ -6,7 +6,7 @@ import {PaginateModel} from "mongoose";
 
 
 // Defining user Mongoose Schema
-const UserGroupSchema = new mongoose.Schema<IUserGroup>({
+const UserGroupMongoSchema = new mongoose.Schema<IUserGroup>({
     name: {
         type: String,
         unique: true,
@@ -27,20 +27,20 @@ const UserGroupSchema = new mongoose.Schema<IUserGroup>({
     }],
 }, {timestamps: true});
 
-UserGroupSchema.set('toJSON', {getters: true});
+UserGroupMongoSchema.set('toJSON', {getters: true});
 
-UserGroupSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+UserGroupMongoSchema.plugin(uniqueValidator, {message: 'validation.unique'});
 
-UserGroupSchema.plugin(MongooseSoftDelete);
-UserGroupSchema.plugin(mongoosePaginate);
+UserGroupMongoSchema.plugin(MongooseSoftDelete);
+UserGroupMongoSchema.plugin(mongoosePaginate);
 
 const USERGROUP_MODEL_NAME = 'UserGroup';
 const USERGROUP_COLLECTION_NAME = 'userGroups';
 
-const UserGroupModel = mongoose.model<IUserGroup,PaginateModel<IUserGroup>>(USERGROUP_MODEL_NAME, UserGroupSchema,USERGROUP_COLLECTION_NAME);
+const UserGroupModel = mongoose.model<IUserGroup,PaginateModel<IUserGroup>>(USERGROUP_MODEL_NAME, UserGroupMongoSchema,USERGROUP_COLLECTION_NAME);
 
 export {
-    UserGroupSchema,
+    UserGroupMongoSchema,
     UserGroupModel
 }
 

package/src/models/UserModel.ts

@@ -6,7 +6,7 @@ import {PaginateModel} from "mongoose";
 
 
 // Defining user Mongoose Schema
-const UserSchema = new mongoose.Schema<IUser>({
+const UserMongoSchema = new mongoose.Schema<IUser>({
     username: {
         type: String,
         unique: true,
@@ -74,22 +74,24 @@ const UserSchema = new mongoose.Schema<IUser>({
     emailCode: {type: String, required: false, index: false, select: false},
     phoneCode: {type: String, required: false, index: false, select: false},
     recoveryCode: {type: String, required: false, index: false, select: false},
-}, {timestamps: true});
+}, {timestamps: true, toJSON: {  virtuals: true}, toObject: { virtuals: true} });
 
-UserSchema.set('toJSON', {getters: true});
+UserMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
 
-UserSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+UserMongoSchema.plugin(uniqueValidator, {message: 'validation.unique'});
 
-UserSchema.plugin(MongooseSoftDelete);
-UserSchema.plugin(mongoosePaginate);
+UserMongoSchema.plugin(MongooseSoftDelete);
+UserMongoSchema.plugin(mongoosePaginate);
 
 const USER_MODEL_NAME = 'User';
 const USER_COLLECTION_NAME = 'users';
 
-const UserModel = mongoose.model<IUser,PaginateModel<IUser>>(USER_MODEL_NAME, UserSchema,USER_COLLECTION_NAME);
+const UserModel = mongoose.models.User as mongoose.Model<IUser> & PaginateModel<IUser> ||  mongoose.model<IUser,PaginateModel<IUser>>(USER_MODEL_NAME, UserMongoSchema,USER_COLLECTION_NAME);
 
 export {
-    UserSchema,
+    UserMongoSchema,
     UserModel
 }
 

package/src/rbac/Rbac.ts

@@ -1,5 +1,5 @@
 import type {IJwtUser, IRole, IRbac} from "@drax/identity-share";
-import {UnauthorizedError} from "@drax/common-back";
+import {UnauthorizedError, ForbiddenError} from "@drax/common-back";
 
 class Rbac implements IRbac{
     private role: IRole;
@@ -26,6 +26,12 @@ class Rbac implements IRbac{
         return this.authUser.tenantId
     }
 
+    assertAuthenticated() {
+        if (!this.authUser) {
+            throw new UnauthorizedError()
+        }
+    }
+
     hasPermission(requiredPermission: string): boolean {
         if (!this.authUser || !this.role || !this.role.permissions || this.role.permissions.length === 0) {
             return false;
@@ -35,27 +41,24 @@ class Rbac implements IRbac{
     }
 
     assertPermission(requiredPermission: string) {
+        this.assertAuthenticated()
         if (!this.hasPermission(requiredPermission)) {
-            throw new UnauthorizedError()
+            throw new ForbiddenError()
         }
     }
 
     assertOrPermissions(requiredPermissions: string[]) {
-
+        this.assertAuthenticated()
         for(let requiredPermission of requiredPermissions){
             if (this.hasPermission(requiredPermission)) {
                 return true
             }
         }
 
-        throw new UnauthorizedError()
+        throw new ForbiddenError()
     }
 
-    assertAuthenticated() {
-        if (!this.authUser) {
-            throw new UnauthorizedError()
-        }
-    }
+
 
     assertUserId(userId: string) {
         if (this.userId != userId) {

package/src/repository/mongo/RoleMongoRepository.ts

@@ -1,106 +1,34 @@
 import {RoleModel} from "../../models/RoleModel.js";
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {mongoose, MongooseQueryFilter, MongooseSort} from "@drax/common-back";
-import {Cursor, PaginateOptions, PaginateResult} from "mongoose";
-import {DeleteResult} from "mongodb";
-import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {Cursor} from "mongoose";
+import {IDraxFindOptions} from "@drax/crud-share";
 import {IRoleBase, IRole} from "@drax/identity-share";
+import {AbstractMongoRepository} from "@drax/crud-back";
 
-class RoleMongoRepository implements IRoleRepository {
+class RoleMongoRepository extends AbstractMongoRepository<IRole, IRoleBase,IRoleBase> implements IRoleRepository {
 
-    _searchFields = ['name']
+    protected _model = RoleModel
+    protected _searchFields = ['name']
+    protected _populateFields = ['childRoles']
+    protected _lean = true
 
-    async create(roleData: IRoleBase): Promise<IRole> {
-        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()
-        return role
-    }
-
-    async delete(id: string): Promise<boolean> {
-        const result: DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
-        return result.deletedCount == 1
-    }
-
-    async findById(id: string): Promise<IRole | null> {
-        const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findById(id).populate('childRoles').exec()
-        return role
+    constructor() {
+        super();
+        this._populateFields =  ['childRoles']
     }
 
     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[]> {
-        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>> {
-        const query = {}
-
-        if (search) {
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
-        }
-
-        MongooseQueryFilter.applyFilters(query, filters)
-
-        const sort = MongooseSort.applySort(orderBy, order)
+        const item = await RoleModel
+            .findOne({name})
+            .populate(this._populateFields)
+            .lean(this._lean ? { virtuals: true } : false)
+            .exec()
 
-        const options = {populate: ['childRoles'], page, limit, sort} as PaginateOptions
-        const roles: PaginateResult<IRole> = await RoleModel.paginate(query, options)
-        return {
-            page: page,
-            limit: limit,
-            total: roles.totalDocs,
-            items: roles.docs
-        }
+        return item as IRole
     }
 
-    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,
@@ -109,13 +37,14 @@ class RoleMongoRepository implements IRoleRepository {
                    search = '',
                    filters = []
                }: IDraxFindOptions): Promise<Cursor> {
-        console.log("RoleMongoRepository.findCursor called")
         const query = {}
 
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if(search){
+            if(mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search)
+            }else{
+                query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
+            }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,108 +1,27 @@
 import {TenantModel} from "../../models/TenantModel.js";
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {mongoose, MongooseSort, MongooseQueryFilter} from "@drax/common-back";
-import {Cursor, PaginateOptions, PaginateResult} from "mongoose";
-import {DeleteResult} from "mongodb";
-import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {Cursor} from "mongoose";
+import {IDraxFindOptions} from "@drax/crud-share";
 import {ITenant, ITenantBase} from "@drax/identity-share";
+import {AbstractMongoRepository} from "@drax/crud-back";
 
-class TenantMongoRepository implements ITenantRepository {
+class TenantMongoRepository extends AbstractMongoRepository<ITenant, ITenantBase, ITenantBase> implements ITenantRepository {
 
-    _searchFields = ['_id','name']
+    protected _model = TenantModel
+    protected _searchFields: string[] = ['name']
+    protected _populateFields: string[] = []
+    protected _lean: boolean = true
 
-    async create(tenantData: ITenantBase): Promise<ITenant> {
-        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()
-        return tenant
-    }
-
-    async delete(id: string): Promise<boolean> {
-        const result: DeleteResult = await TenantModel.deleteOne({_id: id}).exec()
-        return result.deletedCount == 1
-    }
-
-    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> {
-        const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findOne({name}).exec()
-        return tenant
-    }
-
-    async fetchAll(): Promise<ITenant[]> {
-        const tenants: mongoose.HydratedDocument<ITenant>[] = await TenantModel.find().exec()
-        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,
-                       orderBy = '',
-                       order = false,
-                       search = '',
-                       filters = []
-                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
-
-        const query = {}
-
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
-        }
-
-        MongooseQueryFilter.applyFilters(query, filters)
-
-        const sort = MongooseSort.applySort(orderBy, order)
-
-        const options = {page, limit, sort} as PaginateOptions
-        const tenants: PaginateResult<ITenant> = await TenantModel.paginate(query, options)
-        return {
-            page: page,
-            limit: limit,
-            total: tenants.totalDocs,
-            items: tenants.docs
-        }
+        const tenant  = await TenantModel
+            .findOne({name})
+            .lean(this._lean)
+            .exec()
+        return tenant as ITenant
     }
 
-    async find({
-                   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).limit(limit).sort(sort)
-        return items
-    }
 
     async findCursor({
                          limit = 0,
@@ -114,10 +33,12 @@ class TenantMongoRepository implements ITenantRepository {
         console.log("TenantMongoRepository.findCursor called")
         const query = {}
 
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if(search){
+            if(mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search)
+            }else{
+                query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
+            }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)

package/src/repository/mongo/UserApiKeyMongoRepository.ts

@@ -1,78 +1,48 @@
 import {UserApiKeyModel} from "../../models/UserApiKeyModel.js";
 import {
     mongoose,
-    MongooseErrorToValidationError, MongooseQueryFilter, MongooseSort,
-    MongoServerErrorToValidationError,
-    ValidationError
+    MongooseQueryFilter,
+    MongooseSort,
 } from "@drax/common-back"
 import type {IUserApiKey, IUserApiKeyBase, IUserApiKeySoftDelete} from "@drax/identity-share";
-import {DeleteResult, MongoServerError} from "mongodb";
 import {PaginateResult} from "mongoose";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {IUserApiKeyRepository} from "../../interfaces/IUserApiKeyRepository";
+import {AbstractMongoRepository} from "@drax/crud-back";
 
-class UserApiKeyMongoRepository implements IUserApiKeyRepository {
+class UserApiKeyMongoRepository extends AbstractMongoRepository<IUserApiKey,IUserApiKeyBase,IUserApiKeyBase> implements IUserApiKeyRepository {
 
+    protected _searchFields=['name']
+    protected _populateFields  = [
+        {path: 'user', populate: {path: 'tenant role'} },
+        {path: 'createdBy', populate: {path: 'tenant role'} },
+    ]
+    protected _model = UserApiKeyModel
+    protected _lean = false
 
-    constructor() {
-    }
-
-    async create(data: IUserApiKeyBase): Promise<IUserApiKey> {
-        try {
-
-            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = new UserApiKeyModel(data)
-            await userApiKey.save()
-            await userApiKey.populate([
-                {path: 'user', populate: {path: 'tenant role'} },
-                {path: 'createdBy', populate: {path: 'tenant role'} },
-            ])
-            return userApiKey
-        } catch (e) {
-            if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e)
-            }
-            throw e
-        }
-
-    }
-
-    async update(id: string, data: IUserApiKeyBase): Promise<IUserApiKey> {
-        try {
-            delete data.secret
-            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findOneAndUpdate({_id: id}, data, {new: true}).populate({path: 'user', populate: {path: 'tenant role'} }).exec()
-            return userApiKey
-        } catch (e) {
-            if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e)
-            }
-            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
-                throw MongoServerErrorToValidationError(e)
-            }
-            throw e
-        }
-    }
 
     async delete(id: string): Promise<boolean> {
-        const userApiKey: mongoose.HydratedDocument<IUserApiKeySoftDelete> = await UserApiKeyModel.findById(id)
+        const userApiKey: mongoose.HydratedDocument<IUserApiKeySoftDelete> = await UserApiKeyModel
+            .findById(id)
         userApiKey.softDelete()
         return true
     }
 
-    async findById(id: string): Promise<IUserApiKey> {
-        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findById(id).populate({path: 'user', populate: {path: 'tenant role'} }).exec()
-        return userApiKey
-    }
+
 
     async findBySecret(secret: string): Promise<IUserApiKey> {
-        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findOne({secret: {$eq: secret}, deleted: {$ne: true} }).populate({path: 'user', populate: {path: 'tenant role'}}).exec()
-        return userApiKey
+        const userApiKey = await UserApiKeyModel
+            .findOne({secret: {$eq: secret}, deleted: {$ne: true} })
+            .populate(this._populateFields)
+            .exec()
+        return userApiKey as IUserApiKey
     }
 
     async paginate({
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
@@ -81,17 +51,22 @@ class UserApiKeyMongoRepository implements IUserApiKeyRepository {
             deleted: false
         }
 
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if(search){
+            if(mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search)
+            }else{
+                query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
+            }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)
 
         const sort = MongooseSort.applySort(orderBy, order)
-
-        const options = {populate: ['user', 'user.tenant', 'user.role', 'createdBy'], page, limit, sort}
+        const populate = ['user', 'user.tenant', 'user.role', 'createdBy']
+        const lean = this._lean
+        const leanWithId = this._lean
+        const leanWithVirtuals = this._lean
+        const options = {populate , page, limit, sort, lean, leanWithId, leanWithVirtuals}
 
         const userApiKeyPaginated: PaginateResult<IUserApiKey> = await UserApiKeyModel.paginate(query, options)
         return {