@drax/identity-back 0.11.5 → 0.12.2

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

@@ -5,7 +5,7 @@ import { GraphQLError } from "graphql";
 import * as crypto from "node:crypto";
 export default {
     Query: {
-        paginateUserApiKey: async (_, { options = { page: 1, limit: 5, orderBy: "", order: false, search: "", filters: [] } }, { rbac, authUser }) => {
+        paginateUserApiKey: async (_, { options = { page: 1, limit: 5, orderBy: "", order: "asc", search: "", filters: [] } }, { rbac, authUser }) => {
             try {
                 rbac.assertAuthenticated();
                 rbac.assertOrPermissions([
@@ -16,7 +16,7 @@ export default {
                     options.filters = [];
                 }
                 if (!rbac.hasPermission(IdentityPermissions.ViewUserApiKey)) {
-                    options.filters.push({ field: "user", operator: "eq", value: rbac.authUser.id });
+                    options.filters.push({ field: "user", operator: "eq", value: rbac.userId });
                 }
                 const userApiKeyService = UserApiKeyServiceFactory();
                 return await userApiKeyService.paginate(options);

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

@@ -38,7 +38,7 @@ export default {
                 throw new GraphQLError('error.server');
             }
         },
-        paginateUser: async (_, { options = { page: 1, limit: 5, orderBy: "", order: false, search: "", filters: [] } }, { rbac }) => {
+        paginateUser: async (_, { options = { page: 1, limit: 5, orderBy: "", order: "asc", search: "", filters: [] } }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser);
                 let userService = UserServiceFactory();

package/dist/index.js

@@ -27,10 +27,16 @@ import { RolePermissions } from "./permissions/RolePermissions.js";
 import { TenantPermissions } from "./permissions/TenantPermissions.js";
 import { UserPermissions } from "./permissions/UserPermissions.js";
 import { UserApiKeyPermissions } from "./permissions/UserApiKeyPermissions.js";
+import { UserSchema, UserBaseSchema } from "./schemas/UserSchema.js";
+import { TenantSchema, TenantBaseSchema } from "./schemas/TenantSchema.js";
+import { RoleSchema, RoleBaseSchema } from "./schemas/RoleSchema.js";
+import { UserApiKeySchema, UserApiKeyBaseSchema } from "./schemas/UserApiKeySchema.js";
 const graphqlMergeResult = await GraphqlMerge();
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
 export { 
+//Schemas
+UserSchema, UserBaseSchema, TenantSchema, TenantBaseSchema, RoleSchema, RoleBaseSchema, UserApiKeyBaseSchema, UserApiKeySchema, 
 //Service
 UserService, RoleService, TenantService, PermissionService, Rbac, 
 //Factories

package/dist/middleware/apiKeyMiddleware.js

@@ -22,8 +22,8 @@ async function apiKeyMiddleware(request, reply) {
             const userApiKey = await draxCache.getOrLoad(apiKey, userApiKeyLoader);
             if (userApiKey && userApiKey.user) {
                 request.authUser = userApiKey.user;
-                request.authUser.roleId = userApiKey.user.role.id;
-                request.authUser.tenantId = userApiKey.user?.tenant?.id;
+                request.authUser.roleId = userApiKey.user.role._id;
+                request.authUser.tenantId = userApiKey.user?.tenant?._id;
             }
         }
         return;

package/dist/models/RoleModel.js

@@ -2,7 +2,7 @@ import { mongoose, MongooseSoftDelete } from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 const Schema = mongoose.Schema;
-const RoleSchema = new Schema({
+const RoleMongoSchema = new Schema({
     name: {
         type: String, unique: true, required: true, index: true,
     },
@@ -13,13 +13,16 @@ const RoleSchema = new Schema({
             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);
-RoleSchema.set('toJSON', { getters: true });
+RoleMongoSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+RoleMongoSchema.plugin(MongooseSoftDelete);
+RoleMongoSchema.plugin(mongoosePaginate);
+RoleMongoSchema.set('toJSON', { getters: true, virtuals: true });
 const ROLE_MODEL_NAME = 'Role';
 const ROLE_COLLECTION_NAME = 'roles';
-const RoleModel = mongoose.model(ROLE_MODEL_NAME, RoleSchema, ROLE_COLLECTION_NAME);
-export { RoleSchema, RoleModel };
+const RoleModel = mongoose.models.Role || mongoose.model(ROLE_MODEL_NAME, RoleMongoSchema, ROLE_COLLECTION_NAME);
+export { RoleMongoSchema, RoleModel };
 export default RoleModel;

package/dist/models/TenantModel.js

@@ -2,15 +2,18 @@ import { mongoose, MongooseSoftDelete } from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 const Schema = mongoose.Schema;
-const TenantSchema = new Schema({
+const TenantMongoSchema = new Schema({
     name: { type: String, unique: true, required: true, index: true, },
-}, { timestamps: true });
-TenantSchema.plugin(uniqueValidator, { message: 'validation.unique' });
-TenantSchema.plugin(MongooseSoftDelete);
-TenantSchema.plugin(mongoosePaginate);
-TenantSchema.set('toJSON', { getters: true });
+}, { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } });
+TenantMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+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(TENANT_MODEL_NAME, TenantSchema, TENANT_COLLECTION_NAME);
-export { TenantSchema, TenantModel };
+const TenantModel = mongoose.models.Tenant || mongoose.model(TENANT_MODEL_NAME, TenantMongoSchema, TENANT_COLLECTION_NAME);
+export { TenantMongoSchema, TenantModel };
 export default TenantModel;

package/dist/models/UserApiKeyModel.js

@@ -2,7 +2,7 @@ import { mongoose, MongooseSoftDelete } from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 // Defining user Mongoose Schema
-const UserApiKeySchema = new mongoose.Schema({
+const UserApiKeyMongoSchema = new mongoose.Schema({
     name: {
         type: String,
         unique: false,
@@ -38,12 +38,15 @@ const UserApiKeySchema = new mongoose.Schema({
         required: true,
     },
 }, { timestamps: true });
-UserApiKeySchema.set('toJSON', { getters: true });
-UserApiKeySchema.plugin(uniqueValidator, { message: 'validation.unique' });
-UserApiKeySchema.plugin(MongooseSoftDelete);
-UserApiKeySchema.plugin(mongoosePaginate);
+UserApiKeyMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+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(MODEL_NAME, UserApiKeySchema, COLLECTION_NAME);
-export { UserApiKeySchema, UserApiKeyModel };
+const UserApiKeyModel = mongoose.models.UserApiKey || mongoose.model(MODEL_NAME, UserApiKeyMongoSchema, COLLECTION_NAME);
+export { UserApiKeyMongoSchema, UserApiKeyModel };
 export default UserApiKeyModel;

package/dist/models/UserGroupModel.js

@@ -2,7 +2,7 @@ import { mongoose, MongooseSoftDelete } from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 // Defining user Mongoose Schema
-const UserGroupSchema = new mongoose.Schema({
+const UserGroupMongoSchema = new mongoose.Schema({
     name: {
         type: String,
         unique: true,
@@ -22,12 +22,12 @@ const UserGroupSchema = new mongoose.Schema({
             required: false,
         }],
 }, { timestamps: true });
-UserGroupSchema.set('toJSON', { getters: true });
-UserGroupSchema.plugin(uniqueValidator, { message: 'validation.unique' });
-UserGroupSchema.plugin(MongooseSoftDelete);
-UserGroupSchema.plugin(mongoosePaginate);
+UserGroupMongoSchema.set('toJSON', { getters: true });
+UserGroupMongoSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+UserGroupMongoSchema.plugin(MongooseSoftDelete);
+UserGroupMongoSchema.plugin(mongoosePaginate);
 const USERGROUP_MODEL_NAME = 'UserGroup';
 const USERGROUP_COLLECTION_NAME = 'userGroups';
-const UserGroupModel = mongoose.model(USERGROUP_MODEL_NAME, UserGroupSchema, USERGROUP_COLLECTION_NAME);
-export { UserGroupSchema, UserGroupModel };
+const UserGroupModel = mongoose.model(USERGROUP_MODEL_NAME, UserGroupMongoSchema, USERGROUP_COLLECTION_NAME);
+export { UserGroupMongoSchema, UserGroupModel };
 export default UserGroupModel;

package/dist/models/UserModel.js

@@ -2,7 +2,7 @@ import { mongoose, MongooseSoftDelete } from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 // Defining user Mongoose Schema
-const UserSchema = new mongoose.Schema({
+const UserMongoSchema = new mongoose.Schema({
     username: {
         type: String,
         unique: true,
@@ -69,13 +69,15 @@ const UserSchema = new mongoose.Schema({
     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 });
-UserSchema.set('toJSON', { getters: true });
-UserSchema.plugin(uniqueValidator, { message: 'validation.unique' });
-UserSchema.plugin(MongooseSoftDelete);
-UserSchema.plugin(mongoosePaginate);
+}, { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } });
+UserMongoSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+UserMongoSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+UserMongoSchema.plugin(MongooseSoftDelete);
+UserMongoSchema.plugin(mongoosePaginate);
 const USER_MODEL_NAME = 'User';
 const USER_COLLECTION_NAME = 'users';
-const UserModel = mongoose.model(USER_MODEL_NAME, UserSchema, USER_COLLECTION_NAME);
-export { UserSchema, UserModel };
+const UserModel = mongoose.models.User || mongoose.model(USER_MODEL_NAME, UserMongoSchema, USER_COLLECTION_NAME);
+export { UserMongoSchema, UserModel };
 export default UserModel;

package/dist/rbac/Rbac.js

@@ -1,4 +1,4 @@
-import { UnauthorizedError } from "@drax/common-back";
+import { UnauthorizedError, ForbiddenError } from "@drax/common-back";
 class Rbac {
     constructor(authUser, role) {
         this.authUser = authUser;
@@ -16,6 +16,11 @@ class Rbac {
     get tenantId() {
         return this.authUser.tenantId;
     }
+    assertAuthenticated() {
+        if (!this.authUser) {
+            throw new UnauthorizedError();
+        }
+    }
     hasPermission(requiredPermission) {
         if (!this.authUser || !this.role || !this.role.permissions || this.role.permissions.length === 0) {
             return false;
@@ -23,22 +28,19 @@ class Rbac {
         return this.role.permissions.includes(requiredPermission);
     }
     assertPermission(requiredPermission) {
+        this.assertAuthenticated();
         if (!this.hasPermission(requiredPermission)) {
-            throw new UnauthorizedError();
+            throw new ForbiddenError();
         }
     }
     assertOrPermissions(requiredPermissions) {
+        this.assertAuthenticated();
         for (let requiredPermission of requiredPermissions) {
             if (this.hasPermission(requiredPermission)) {
                 return true;
             }
         }
-        throw new UnauthorizedError();
-    }
-    assertAuthenticated() {
-        if (!this.authUser) {
-            throw new UnauthorizedError();
-        }
+        throw new ForbiddenError();
     }
     assertUserId(userId) {
         if (this.userId != userId) {

package/dist/repository/mongo/RoleMongoRepository.js

@@ -1,77 +1,32 @@
 import { RoleModel } from "../../models/RoleModel.js";
-import { MongooseQueryFilter, MongooseSort } from "@drax/common-back";
-class RoleMongoRepository {
+import { mongoose, MongooseQueryFilter, MongooseSort } from "@drax/common-back";
+import { AbstractMongoRepository } from "@drax/crud-back";
+class RoleMongoRepository extends AbstractMongoRepository {
     constructor() {
+        super();
+        this._model = RoleModel;
         this._searchFields = ['name'];
-    }
-    async create(roleData) {
-        const role = new RoleModel(roleData);
-        await role.save();
-        await role.populate('childRoles');
-        return role;
-    }
-    async update(id, roleData) {
-        const role = await RoleModel.findOneAndUpdate({ _id: id }, roleData, { new: true }).populate('childRoles').exec();
-        return role;
-    }
-    async delete(id) {
-        const result = await RoleModel.deleteOne({ _id: id }).exec();
-        return result.deletedCount == 1;
-    }
-    async findById(id) {
-        const role = await RoleModel.findById(id).populate('childRoles').exec();
-        return role;
+        this._populateFields = ['childRoles'];
+        this._lean = true;
+        this._populateFields = ['childRoles'];
     }
     async findByName(name) {
-        const role = await RoleModel.findOne({ name }).populate('childRoles').exec();
-        return role;
-    }
-    async fetchAll() {
-        const roles = await RoleModel.find().populate('childRoles').exec();
-        return roles;
-    }
-    async search(value, limit = 1000) {
-        const query = {};
-        if (value) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
-        }
-        const items = await RoleModel.find(query).limit(limit).exec();
-        return items;
-    }
-    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
-        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 options = { populate: ['childRoles'], page, limit, sort };
-        const roles = await RoleModel.paginate(query, options);
-        return {
-            page: page,
-            limit: limit,
-            total: roles.totalDocs,
-            items: roles.docs
-        };
-    }
-    async find({ 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);
-        return await RoleModel.find(query).limit(limit).sort(sort);
+        const item = await RoleModel
+            .findOne({ name })
+            .populate(this._populateFields)
+            .lean(this._lean ? { virtuals: true } : false)
+            .exec();
+        return item;
     }
     async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
-        console.log("RoleMongoRepository.findCursor called");
         const query = {};
         if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
+            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);

package/dist/repository/mongo/TenantMongoRepository.js

@@ -1,79 +1,31 @@
 import { TenantModel } from "../../models/TenantModel.js";
-import { MongooseSort, MongooseQueryFilter } from "@drax/common-back";
-class TenantMongoRepository {
+import { mongoose, MongooseSort, MongooseQueryFilter } from "@drax/common-back";
+import { AbstractMongoRepository } from "@drax/crud-back";
+class TenantMongoRepository extends AbstractMongoRepository {
     constructor() {
-        this._searchFields = ['_id', 'name'];
-    }
-    async create(tenantData) {
-        const tenant = new TenantModel(tenantData);
-        await tenant.save();
-        return tenant;
-    }
-    async update(id, tenantData) {
-        const tenant = await TenantModel.findOneAndUpdate({ _id: id }, tenantData, { new: true }).exec();
-        return tenant;
-    }
-    async delete(id) {
-        const result = await TenantModel.deleteOne({ _id: id }).exec();
-        return result.deletedCount == 1;
-    }
-    async findById(id) {
-        const tenant = await TenantModel.findById(id).exec();
-        return tenant;
+        super(...arguments);
+        this._model = TenantModel;
+        this._searchFields = ['name'];
+        this._populateFields = [];
+        this._lean = true;
     }
     async findByName(name) {
-        const tenant = await TenantModel.findOne({ name }).exec();
+        const tenant = await TenantModel
+            .findOne({ name })
+            .lean(this._lean)
+            .exec();
         return tenant;
     }
-    async fetchAll() {
-        const tenants = await TenantModel.find().exec();
-        return tenants;
-    }
-    async search(value, limit = 1000) {
-        const query = {};
-        if (value) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
-        }
-        const items = await TenantModel.find(query).limit(limit).exec();
-        return items;
-    }
-    async paginate({ page = 1, limit = 5, 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 options = { page, limit, sort };
-        const tenants = await TenantModel.paginate(query, options);
-        return {
-            page: page,
-            limit: limit,
-            total: tenants.totalDocs,
-            items: tenants.docs
-        };
-    }
-    async find({ 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).limit(limit).sort(sort);
-        return items;
-    }
     async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         console.log("TenantMongoRepository.findCursor called");
         const query = {};
         if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
+            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);

package/dist/repository/mongo/UserApiKeyMongoRepository.js

@@ -1,67 +1,49 @@
 import { UserApiKeyModel } from "../../models/UserApiKeyModel.js";
-import { mongoose, MongooseErrorToValidationError, MongooseQueryFilter, MongooseSort, MongoServerErrorToValidationError } from "@drax/common-back";
-import { MongoServerError } from "mongodb";
-class UserApiKeyMongoRepository {
+import { mongoose, MongooseQueryFilter, MongooseSort, } from "@drax/common-back";
+import { AbstractMongoRepository } from "@drax/crud-back";
+class UserApiKeyMongoRepository extends AbstractMongoRepository {
     constructor() {
-    }
-    async create(data) {
-        try {
-            const userApiKey = 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, data) {
-        try {
-            delete data.secret;
-            const userApiKey = 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;
-        }
+        super(...arguments);
+        this._searchFields = ['name'];
+        this._populateFields = [
+            { path: 'user', populate: { path: 'tenant role' } },
+            { path: 'createdBy', populate: { path: 'tenant role' } },
+        ];
+        this._model = UserApiKeyModel;
+        this._lean = false;
     }
     async delete(id) {
-        const userApiKey = await UserApiKeyModel.findById(id);
+        const userApiKey = await UserApiKeyModel
+            .findById(id);
         userApiKey.softDelete();
         return true;
     }
-    async findById(id) {
-        const userApiKey = await UserApiKeyModel.findById(id).populate({ path: 'user', populate: { path: 'tenant role' } }).exec();
-        return userApiKey;
-    }
     async findBySecret(secret) {
-        const userApiKey = await UserApiKeyModel.findOne({ secret: { $eq: secret }, deleted: { $ne: true } }).populate({ path: 'user', populate: { path: 'tenant role' } }).exec();
+        const userApiKey = await UserApiKeyModel
+            .findOne({ secret: { $eq: secret }, deleted: { $ne: true } })
+            .populate(this._populateFields)
+            .exec();
         return userApiKey;
     }
-    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
+    async paginate({ page = 1, limit = 5, orderBy = '', order = "asc", search = '', filters = [] }) {
         const query = {
             deleted: false
         };
         if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
+            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 = await UserApiKeyModel.paginate(query, options);
         return {
             page: page,