@drax/identity-back 0.0.21 → 0.0.24

package/src/index.ts

@@ -25,23 +25,20 @@ import LoadPermissions from "./setup/LoadPermissions.js";
 import LoadIdentityConfigFromEnv from "./setup/LoadIdentityConfigFromEnv.js";
 import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
 
-import type {IJwtUser} from "./interfaces/IJwtUser";
-import type {IRole, IRoleBase} from "./interfaces/IRole";
-import type {IUser, IUserCreate, IUserUpdate} from "./interfaces/IUser";
-import type {IUserRepository} from "./interfaces/IUserRepository";
 import type {IRoleRepository} from "./interfaces/IRoleRepository";
+import type {ITenantRepository} from "./interfaces/ITenantRepository";
+import type {IUserRepository} from "./interfaces/IUserRepository";
+
 
 const graphqlMergeResult = await GraphqlMerge()
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
 
+
 export type {
-    IJwtUser,
-    IRole,
-    IRoleBase,
     IRoleRepository,
-    IUser, IUserCreate, IUserUpdate,
-    IUserRepository
+    ITenantRepository,
+    IUserRepository,
 }
 
 export {

package/src/interfaces/IRoleRepository.ts

@@ -1,15 +1,10 @@
-import {IRole} from './IRole'
-import {IPaginateFilter, IPaginateResult} from "@drax/common-back";
-import {IID} from "./IID";
-interface IRoleRepository{
-    create(role: IRole): Promise<IRole>;
-    update(id: IID, updatedRole: IRole): Promise<IRole | null>;
-    delete(id: IID): Promise<boolean>;
-    findById(id: IID): Promise<IRole | null>;
+import {IRole, IRoleBase} from "@drax/identity-share";
+import {IDraxCrud} from "@drax/common-share";
+
+interface IRoleRepository extends IDraxCrud<IRole, IRoleBase, IRoleBase> {
+    findById(id: string): Promise<IRole | null>;
     findByName(name: string): Promise<IRole | null>;
     fetchAll(): Promise<IRole[]>;
-    paginate(page?: number, limit?: number, search?:string, filters?: IPaginateFilter[]): Promise<IPaginateResult>;
-    table?():void
 }
 
 export {IRoleRepository}

package/src/interfaces/ITenantRepository.ts

@@ -1,15 +1,9 @@
-import {ITenant} from './ITenant'
-import {IPaginateFilter, IPaginateResult} from "@drax/common-back";
-import {IID} from "./IID";
-interface ITenantRepository{
-    create(role: ITenant): Promise<ITenant>;
-    update(id: IID, updatedRole: ITenant): Promise<ITenant | null>;
-    delete(id: IID): Promise<boolean>;
-    findById(id: IID): Promise<ITenant | null>;
+import {ITenant, ITenantBase} from '@drax/identity-share'
+import {IDraxCrud} from "@drax/common-share";
+interface ITenantRepository extends IDraxCrud<ITenant,ITenantBase,ITenantBase>{
+    findById(id: string): Promise<ITenant | null>;
     findByName(name: string): Promise<ITenant | null>;
     fetchAll(): Promise<ITenant[]>;
-    paginate(page?: number, limit?: number, search?:string, filters?: IPaginateFilter[]): Promise<IPaginateResult>;
-    table?():void
 }
 
 export {ITenantRepository}

package/src/interfaces/IUserRepository.ts

@@ -1,16 +1,10 @@
-import {IUser, IUserCreate, IUserUpdate} from './IUser'
-import {IPaginateFilter, IPaginateResult} from "@drax/common-back";
-import {IID} from "./IID";
-interface IUserRepository{
-    create(role: IUserCreate): Promise<IUser>;
-    update(id: IID, updatedRole: IUserUpdate): Promise<IUser | null>;
-    delete(id: IID): Promise<boolean>;
-    findById(id: IID): Promise<IUser | null>;
-    findByUsername(username: string): Promise<IUser | null>;
-    paginate(page?: number, limit?: number, search?: string, filters?: IPaginateFilter[]): Promise<IPaginateResult>;
-    changePassword(id: IID, password:string):Promise<Boolean>;
-    table?():void
+import {IUser, IUserCreate, IUserUpdate} from '@drax/identity-share'
+import {IDraxCrud} from "@drax/common-share";
 
+interface IUserRepository extends IDraxCrud<IUser, IUserCreate, IUserUpdate>{
+    findById(id: string): Promise<IUser | null>;
+    findByUsername(username: string): Promise<IUser | null>;
+    changePassword(id: string, password:string):Promise<Boolean>;
 }
 
 export {IUserRepository}

package/src/middleware/jwtMiddleware.ts

@@ -1,5 +1,5 @@
 import AuthUtils from "../utils/AuthUtils.js";
-import {IJwtUser} from "../interfaces/IJwtUser";
+import {IJwtUser} from "@drax/identity-share";
 
 function jwtMiddleware (request, reply, done) {
         try{

package/src/middleware/rbacMiddleware.ts

@@ -1,5 +1,4 @@
-import type {IJwtUser} from "../interfaces/IJwtUser";
-import type {IRole} from "../interfaces/IRole";
+import {IJwtUser, IRole} from "@drax/identity-share";
 import {DraxCache, DraxConfig} from "@drax/common-back";
 import RoleServiceFactory from "../factory/RoleServiceFactory.js";
 import Rbac from "../rbac/Rbac.js";

package/src/models/RoleModel.ts

@@ -1,7 +1,7 @@
 import {mongoose, MongooseSoftDelete} from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2'
-import {IRole} from '../interfaces/IRole'
+import {IRole} from '@drax/identity-share'
 const Schema = mongoose.Schema
 import {PaginateModel} from "mongoose";
 

package/src/models/TenantModel.ts

@@ -1,7 +1,7 @@
 import {mongoose, MongooseSoftDelete} from '@drax/common-back';
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2'
-import {ITenant} from '../interfaces/ITenant'
+import {ITenant} from '@drax/identity-share'
 const Schema = mongoose.Schema
 import {PaginateModel} from "mongoose";
 

package/src/models/UserGroupModel.ts

@@ -1,5 +1,5 @@
 import {mongoose, MongooseSoftDelete} from '@drax/common-back';
-import {IUserGroup} from "../interfaces/IUserGroup";
+import {IUserGroup} from "@drax/identity-share";
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2'
 import {PaginateModel} from "mongoose";

package/src/models/UserModel.ts

@@ -1,5 +1,5 @@
 import {mongoose, MongooseSoftDelete} from '@drax/common-back';
-import {IUser} from "../interfaces/IUser";
+import {IUser} from "@drax/identity-share";
 import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2'
 import {PaginateModel} from "mongoose";
@@ -33,13 +33,13 @@ const UserSchema = new mongoose.Schema<IUser>({
             message: "Invalid email format"
         }
     },
-    password: {type: String, required: true},
-    code: {type: String, required: false},
-    name: {type: String, required: false},
-    active: {type: Boolean, required: true, default: false},
+    password: {type: String, required: true,  index: false},
+    name: {type: String, required: false,  index: false},
+    active: {type: Boolean, required: true, default: false,  index: false},
     phone: {
         type: String,
         required: false,
+        index: false,
         validate: {
             validator: function (value: string) {
                 let r = /[0-9]+/;
@@ -48,33 +48,25 @@ const UserSchema = new mongoose.Schema<IUser>({
             message: "Invalid Phone format"
         }
     },
-    avatar: {type: String, required: false},
+    avatar: {type: String, required: false, index:false},
     role: {
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Role',
         required: true,
+        index: false
     },
     tenant: {
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Tenant',
         required: false,
+        index: false
     },
     groups: [{
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Group',
         required: false,
+        index: false
     }],
-  /*  refreshToken: {
-        type: [
-            {
-                id: {type: String},
-                expiryDate: {type: Date},
-                sessionId: {type: String},
-            }
-        ],
-        default: [],
-        id: false
-    }*/
 }, {timestamps: true});
 
 UserSchema.set('toJSON', {getters: true});

package/src/rbac/Rbac.ts

@@ -1,5 +1,4 @@
-import {IRole} from "../interfaces/IRole";
-import {IJwtUser} from "../interfaces/IJwtUser";
+import {IJwtUser, IRole} from "@drax/identity-share";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 
 class Rbac{

package/src/repository/mongo/RoleMongoRepository.ts

@@ -1,30 +1,31 @@
 import {RoleModel} from "../../models/RoleModel.js";
-import {IRole} from '../../interfaces/IRole'
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
-import {IPaginateFilter, IPaginateResult, mongoose} from "@drax/common-back";
+import { mongoose} from "@drax/common-back";
 import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IRoleBase, IRole} from "@drax/identity-share";
 
 class RoleMongoRepository implements IRoleRepository{
 
-    async create(roleData: IRole): Promise<IRole> {
+    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: mongoose.Types.ObjectId | string, roleData: IRole): Promise<IRole> {
+    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: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result : DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: mongoose.Types.ObjectId): 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
     }
@@ -39,8 +40,13 @@ class RoleMongoRepository implements IRoleRepository{
         return roles
     }
 
-    async paginate(page:number = 1, limit:number = 5, search:string): Promise<IPaginateResult>{
-
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         const query = {}
 
         if(search){

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,29 +1,30 @@
 import {TenantModel} from "../../models/TenantModel.js";
-import {ITenant} from '../../interfaces/ITenant'
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
-import {IPaginateFilter, IPaginateResult, mongoose} from "@drax/common-back";
+import { mongoose} from "@drax/common-back";
 import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {ITenant, ITenantBase} from "@drax/identity-share";
 
 class TenantMongoRepository implements ITenantRepository{
 
-    async create(tenantData: ITenant): Promise<ITenant> {
+    async create(tenantData: ITenantBase): Promise<ITenant> {
         const tenant : mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
         await tenant.save()
         return tenant
     }
 
-    async update(id: mongoose.Types.ObjectId | string, tenantData: ITenant): Promise<ITenant> {
+    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: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result : DeleteResult = await TenantModel.deleteOne({_id:id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: mongoose.Types.ObjectId): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null>{
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findById(id).exec()
         return tenant
     }
@@ -38,7 +39,13 @@ class TenantMongoRepository implements ITenantRepository{
         return tenants
     }
 
-    async paginate(page:number = 1, limit:number = 5, search:string): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
 
         const query = {}
 

package/src/repository/mongo/UserMongoRepository.ts

@@ -1,11 +1,11 @@
 import {UserModel} from "../../models/UserModel.js";
 import {mongoose, MongooseErrorToValidationError, MongoServerErrorToValidationError, ValidationError} from "@drax/common-back"
-import type {IPaginateFilter, IPaginateResult} from "@drax/common-back"
-import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser";
+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 RoleMongoRepository from "./RoleMongoRepository.js";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
 
 class UserMongoRepository implements IUserRepository {
     private roleRepository: RoleMongoRepository;
@@ -18,7 +18,7 @@ class UserMongoRepository implements IUserRepository {
     async create(userData: IUserCreate): Promise<IUser> {
         try{
 
-            if(!await this.roleRepository.findById(userData.role as mongoose.Types.ObjectId)){
+            if(!await this.roleRepository.findById(userData.role)){
                 throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
             }
 
@@ -35,7 +35,7 @@ class UserMongoRepository implements IUserRepository {
 
     }
 
-    async update(id: mongoose.Types.ObjectId, userData: IUserUpdate): Promise<IUser> {
+    async update(id: string, userData: IUserUpdate): Promise<IUser> {
         try{
         const user: mongoose.HydratedDocument<IUser> = await UserModel.findOneAndUpdate({_id: id}, userData, {new: true}).populate(['role','tenant']).exec()
         return user
@@ -50,13 +50,13 @@ class UserMongoRepository implements IUserRepository {
         }
     }
 
-    async delete(id: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result: DeleteResult = await UserModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
 
-    async findById(id: mongoose.Types.ObjectId): Promise<IUser> {
+    async findById(id:string): Promise<IUser> {
         const user: mongoose.HydratedDocument<IUser> = await UserModel.findById(id).populate(['role','tenant']).exec()
         return user
     }
@@ -66,8 +66,13 @@ class UserMongoRepository implements IUserRepository {
         return user
     }
 
-    async paginate(page: number = 1, limit: number = 5, search?:string, filters?:IPaginateFilter[]): Promise<IPaginateResult> {
-
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
 
         const query = {}
 
@@ -104,7 +109,7 @@ class UserMongoRepository implements IUserRepository {
         }
     }
 
-    async changePassword(id: mongoose.Types.ObjectId, password: string):Promise<boolean> {
+    async changePassword(id: string, password: string):Promise<boolean> {
         try{
         await UserModel.findOneAndUpdate({_id: id}, {password}).exec()
         return true

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -1,11 +1,10 @@
-import {IRole} from '../../interfaces/IRole'
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IPaginateFilter, IPaginateResult, ValidationError} from "@drax/common-back";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IRole, IRoleBase} from "@drax/identity-share";
 import {SqliteErrorToValidationError} from "@drax/common-back";
-import {IID} from "../../interfaces/IID";
 
 const roleTableSQL: string = `
     CREATE TABLE IF NOT EXISTS roles
@@ -32,7 +31,7 @@ class RoleSqliteRepository implements IRoleRepository{
         this.db.exec(roleTableSQL);
     }
 
-    normalizeData(roleData: IRole){
+    normalizeData(roleData: IRoleBase){
 
         roleData.readonly = roleData.readonly ? 1 : 0
 
@@ -45,7 +44,7 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async create(roleData: IRole): Promise<IRole> {
+    async create(roleData: IRoleBase): Promise<IRole> {
         try{
 
             if(!roleData.id){
@@ -76,25 +75,9 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async findById(id: IID): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
-        if(role){
-            await this.populateRole(role)
-            return role
-        }
-        return undefined
-    }
 
-    async findByName(name: string): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
-        if(role){
-            await this.populateRole(role)
-            return role
-        }
-        return undefined
-    }
 
-    async update(id: IID, roleData: IRole): Promise<IRole> {
+    async update(id: string, roleData: IRoleBase): Promise<IRole> {
         try{
             this.normalizeData(roleData)
             const setClauses = Object.keys(roleData)
@@ -111,27 +94,13 @@ class RoleSqliteRepository implements IRoleRepository{
 
     }
 
-    async delete(id: IID): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
-        stmt.run(id);
-        return true
-    }
-
-    async deleteAll(): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles');
-        stmt.run();
-        return true
-    }
-
-    async fetchAll(): Promise<IRole[]>{
-        const roles = this.db.prepare('SELECT * FROM roles').all();
-        for (const role of roles) {
-            await this.populateRole(role)
-        }
-        return roles
-    }
-
-    async paginate(page = 1, limit = 5, search=""): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>{
         const offset = page > 1 ? (page - 1) * limit : 0
 
         let where=""
@@ -154,7 +123,47 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async findWithoutPopulateById(id: IID): Promise<IRole | null>{
+    async delete(id: string): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
+        stmt.run(id);
+        return true
+    }
+
+    async deleteAll(): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM roles');
+        stmt.run();
+        return true
+    }
+
+    async findById(id: string): Promise<IRole | null>{
+        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        if(role){
+            await this.populateRole(role)
+            return role
+        }
+        return undefined
+    }
+
+    async findByName(name: string): Promise<IRole | null>{
+        const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
+        if(role){
+            await this.populateRole(role)
+            return role
+        }
+        return undefined
+    }
+
+    async fetchAll(): Promise<IRole[]>{
+        const roles = this.db.prepare('SELECT * FROM roles').all();
+        for (const role of roles) {
+            await this.populateRole(role)
+        }
+        return roles
+    }
+
+
+
+    async findWithoutPopulateById(id: string): Promise<IRole | null>{
         const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
         if(role){
             return role

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -1,11 +1,10 @@
-import {ITenant} from '../../interfaces/ITenant'
+import {ITenant, ITenantBase} from '@drax/identity-share'
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IPaginateFilter, IPaginateResult, ValidationError} from "@drax/common-back";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import {SqliteErrorToValidationError} from "@drax/common-back";
-import {IID} from "../../interfaces/IID";
 
 const tenantTableSQL: string = `
     CREATE TABLE IF NOT EXISTS tenants
@@ -30,7 +29,7 @@ class TenantSqliteRepository implements ITenantRepository{
 
 
 
-    async create(tenantData: ITenant): Promise<ITenant> {
+    async create(tenantData: ITenantBase): Promise<ITenant> {
         try{
 
             if(!tenantData.id){
@@ -55,25 +54,17 @@ class TenantSqliteRepository implements ITenantRepository{
         }
     }
 
-    async findById(id: IID): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null>{
         const tenant = this.db.prepare('SELECT * FROM tenants WHERE id = ?').get(id);
-        if(tenant){
-            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : []
-            return tenant
-        }
-        return undefined
+        return tenant
     }
 
     async findByName(name: string): Promise<ITenant | null>{
         const tenant = this.db.prepare('SELECT * FROM tenants WHERE name = ?').get(name);
-        if(tenant){
-            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : []
-            return tenant
-        }
-        return undefined
+        return tenant
     }
 
-    async update(id: IID, tenantData: ITenant): Promise<ITenant> {
+    async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
         try{
             const setClauses = Object.keys(tenantData)
                 .map(field => `${field} = @${field}`)
@@ -89,7 +80,7 @@ class TenantSqliteRepository implements ITenantRepository{
 
     }
 
-    async delete(id: IID): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const stmt = this.db.prepare('DELETE FROM tenants WHERE id = ?');
         stmt.run(id);
         return true
@@ -109,7 +100,13 @@ class TenantSqliteRepository implements ITenantRepository{
         return tenants
     }
 
-    async paginate(page = 1, limit = 5, search=""): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>{
         const offset = page > 1 ? (page - 1) * limit : 0
 
         let where=""
@@ -120,11 +117,6 @@ class TenantSqliteRepository implements ITenantRepository{
         const rCount = this.db.prepare('SELECT COUNT(*) as count FROM tenants'+where).get();
         const tenants = this.db.prepare('SELECT * FROM tenants LIMIT ? OFFSET ?'+where).all([limit, offset]);
 
-        for (const tenant of tenants) {
-            tenant.permissions = tenant.permissions? tenant.permissions.split(",") : []
-        }
-
-
         return {
             page: page,
             limit: limit,