@holoyan/adonisjs-permissions 0.1.0 → 0.5.2

package/build/src/services/model_has_role_permissions.js

@@ -1,172 +1,153 @@
-import { destructTarget, formatList, morphMap } from './helper.js';
+import { destructTarget, formatList } from './helper.js';
 export class ModelHasRolePermissions {
     model;
     roleService;
     permissionsService;
-    constructor(model, roleService, permissionsService) {
+    map;
+    constructor(model, roleService, permissionsService, map) {
         this.model = model;
         this.roleService = roleService;
         this.permissionsService = permissionsService;
+        this.map = map;
     }
     // roles related section BEGIN
     async roles() {
-        const map = await morphMap();
-        return this.roleService.all(map.getAlias(this.model), this.model.getModelId());
+        return this.roleService.all(this.map.getAlias(this.model), this.model.getModelId());
     }
-    async hasRole(role) {
-        const map = await morphMap();
-        return this.roleService.has(map.getAlias(this.model), this.model.getModelId(), role);
+    hasRole(role) {
+        return this.roleService.has(this.map.getAlias(this.model), this.model.getModelId(), role);
     }
-    async hasAllRoles(roles) {
-        const map = await morphMap();
-        return this.roleService.hasAll(map.getAlias(this.model), this.model.getModelId(), roles);
+    hasAllRoles(...roles) {
+        return this.roleService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), roles);
     }
-    async hasAnyRole(roles) {
-        const map = await morphMap();
-        return this.roleService.hasAll(map.getAlias(this.model), this.model.getModelId(), roles);
+    hasAnyRole(...roles) {
+        return this.roleService.hasAny(this.map.getAlias(this.model), this.model.getModelId(), roles);
     }
-    async assignRole(role) {
-        const map = await morphMap();
-        return this.roleService.assign(role, map.getAlias(this.model), this.model.getModelId());
+    assignRole(role) {
+        return this.roleService.assign(role, this.map.getAlias(this.model), this.model.getModelId());
+    }
+    assignAllRoles(...roles) {
+        return this.roleService.assignAll(roles, this.map.getAlias(this.model), this.model.getModelId());
     }
     revokeRole(role) {
-        return this.revokeAllRoles([role]);
+        return this.revokeAllRoles(role);
     }
-    revokeAllRoles(roles) {
+    revokeAllRoles(...roles) {
         const { slugs, ids } = formatList(roles);
         return this.roleService.revokeAll([...slugs, ...ids], this.model);
     }
+    flushRoles() {
+        return this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
+    }
     // roles related section END
     // permissions related section BEGIN
-    async permissions(includeForbiddens = false) {
-        const map = await morphMap();
-        return this.permissionsService.all(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    async permissions(includeForbiddings = false) {
+        return this.permissionsService.all(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
-    async globalPermissions(includeForbiddens = false) {
-        const map = await morphMap();
-        return this.permissionsService.global(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    async globalPermissions(includeForbiddings = false) {
+        return this.permissionsService.global(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
-    async onResourcePermissions(includeForbiddens = false) {
-        const map = await morphMap();
-        return this.permissionsService.onResource(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    async onResourcePermissions(includeForbiddings = false) {
+        return this.permissionsService.onResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
-    async directGlobalPermissions(includeForbiddens = false) {
-        const map = await morphMap();
-        return this.permissionsService.directGlobal(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    async directGlobalPermissions(includeForbiddings = false) {
+        return this.permissionsService.directGlobal(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
-    async directResourcePermissions(includeForbiddens = false) {
-        const map = await morphMap();
-        return this.permissionsService.directResource(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    async directResourcePermissions(includeForbiddings = false) {
+        return this.permissionsService.directResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
-    async containsPermission(permisison) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAny(map.getAlias(this.model), this.model.getModelId(), [permisison]);
+    async containsPermission(permission) {
+        const result = await this.permissionsService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
         return result;
     }
-    async containsAllPermissions(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAll(map.getAlias(this.model), this.model.getModelId(), permisisons);
+    async containsAllPermissions(permissions) {
+        const result = await this.permissionsService.containsAll(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
-    async containsAnyPermission(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAny(map.getAlias(this.model), this.model.getModelId(), permisisons);
+    async containsAnyPermission(permissions) {
+        const result = await this.permissionsService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
-    async containsDirectPermission(permisison) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAnyDirect(map.getAlias(this.model), this.model.getModelId(), [permisison]);
+    async containsDirectPermission(permission) {
+        const result = await this.permissionsService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
         return result;
     }
-    async containsAllPermissionsDirectly(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAllDirect(map.getAlias(this.model), this.model.getModelId(), permisisons);
-        return result;
+    containsAllPermissionsDirectly(permissions) {
+        return this.permissionsService.containsAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
     }
-    async containsAnyPermissionDirectly(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionsService.containsAnyDirect(map.getAlias(this.model), this.model.getModelId(), permisisons);
+    async containsAnyPermissionDirectly(permissions) {
+        const result = await this.permissionsService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
-    async hasPermission(permisison, target) {
-        return this.hasAnyPermission([permisison], target);
+    async hasPermission(permission, target) {
+        return this.hasAnyPermission([permission], target);
     }
-    async hasAllPermissions(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionsService.hasAll(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
-        return result;
+    async hasAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return await this.permissionsService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async hasAnyPermission(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionsService.hasAny(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
-        return result;
+    async hasAnyPermission(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return await this.permissionsService.hasAny(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async hasAnyDirectPermission(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionsService.hasAnyDirect(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
-        return result;
+    async hasAnyDirectPermission(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return await this.permissionsService.hasAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async hasDirectPermission(permisison, target) {
-        return this.hasAnyDirectPermission([permisison], target);
+    async hasDirectPermission(permission, target) {
+        return this.hasAnyDirectPermission([permission], target);
     }
-    async hasAllPermissionsDirect(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionsService.hasAllDirect(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
-        return result;
+    async hasAllPermissionsDirect(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return await this.permissionsService.hasAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+    }
+    can(permission, target) {
+        return this.hasPermission(permission, target);
     }
-    can(permisison, target) {
-        return this.hasPermission(permisison, target);
+    canAll(permissions, target) {
+        return this.hasAllPermissions(permissions, target);
     }
-    canAll(permisisons, target) {
-        return this.hasAllPermissions(permisisons, target);
+    canAny(permissions, target) {
+        return this.hasAnyPermission(permissions, target);
     }
-    canAny(permisisons, target) {
-        return this.hasAnyPermission(permisisons, target);
+    async assignDirectPermission(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), [permission], entity.targetClass, entity.targetId, true);
     }
-    async assignDirectPermission(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionsService.giveAll(map.getAlias(this.model), this.model.getModelId(), [permisison], entity.targetClass, entity.targetId, true);
+    async assignDirectAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
     }
-    allow(permisison, target) {
-        return this.assignDirectPermission(permisison, target);
+    allow(permission, target) {
+        return this.assignDirectPermission(permission, target);
     }
-    async revokePermission(permisison, target) {
-        return this.revokeAllPermissions([permisison], target);
+    async revokePermission(permission, target) {
+        return this.revokeAllPermissions([permission], target);
     }
-    async revokeAllPermissions(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionsService.revokeAll(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async revokeAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionsService.revokeAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async flushPermissions() {
-        const map = await morphMap();
-        return this.permissionsService.flush(map.getAlias(this.model), this.model.getModelId());
+        return this.permissionsService.flush(this.map.getAlias(this.model), this.model.getModelId());
     }
     async flush() {
-        const map = await morphMap();
-        await this.permissionsService.flush(map.getAlias(this.model), this.model.getModelId());
-        await this.roleService.flush(map.getAlias(this.model), this.model.getModelId());
+        await this.permissionsService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        await this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
         return true;
     }
-    async forbid(permisison, target) {
-        return this.forbidAll([permisison], target);
+    async forbid(permission, target) {
+        return this.forbidAll([permission], target);
     }
-    async forbidAll(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionsService.forbidAll(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async forbidAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionsService.forbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async unforbidAll(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionsService.unforbidAll(map.getAlias(this.model), this.model.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async unforbidAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionsService.unforbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async unforbid(permisison, target) {
-        return this.unforbidAll([permisison], target);
+    async unforbid(permission, target) {
+        return this.unforbidAll([permission], target);
     }
 }

package/build/src/services/model_service.d.ts

@@ -1,8 +1,17 @@
-import ModelPermission from '../models/model_permission.js';
-import ModelRole from '../models/model_role.js';
-export default class ModelService {
-    all(roleId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof ModelRole, ModelRole>;
+import BaseService from './base_service.js';
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { MorphInterface } from '../types.js';
+export default class ModelService extends BaseService {
+    private modelPermissionClassName;
+    private modelRoleClassName;
+    private map;
+    private modelPermissionQuery;
+    private readonly modelPermissionTable;
+    private modelRoleQuery;
+    private readonly modelRoleTable;
+    constructor(modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
+    all(roleId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     allFor(modelType: string, roleId: number): Promise<any>;
-    allByPermission(permissionId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof ModelPermission, ModelPermission>;
-    allByPermissionFor(modelType: string, permisisonId: number): Promise<any>;
+    allByPermission(permissionId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    allByPermissionFor(modelType: string, permissionId: number): Promise<any>;
 }

package/build/src/services/model_service.js

@@ -1,31 +1,56 @@
-import ModelPermission from '../models/model_permission.js';
-import ModelRole from '../models/model_role.js';
-import { morphMap } from './helper.js';
-export default class ModelService {
+import BaseService from './base_service.js';
+import { getModelPermissionModelQuery, getModelRoleModelQuery } from './query_helper.js';
+export default class ModelService extends BaseService {
+    modelPermissionClassName;
+    modelRoleClassName;
+    map;
+    // private permissionQuery
+    // private readonly permissionTable
+    // private roleQuery
+    // private readonly roleTable
+    modelPermissionQuery;
+    modelPermissionTable;
+    modelRoleQuery;
+    modelRoleTable;
+    constructor(
+    // private roleClassName: typeof BaseModel,
+    // private permissionClassName: typeof BaseModel,
+    modelPermissionClassName, modelRoleClassName, map) {
+        super();
+        this.modelPermissionClassName = modelPermissionClassName;
+        this.modelRoleClassName = modelRoleClassName;
+        this.map = map;
+        // this.permissionQuery = getPermissionModelQuery(this.permissionClassName)
+        // this.permissionTable = this.permissionClassName.table
+        // this.roleQuery = getRoleModelQuery(this.roleClassName)
+        // this.roleTable = this.roleClassName.table
+        this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName);
+        this.modelPermissionTable = this.modelPermissionClassName.table;
+        this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName);
+        this.modelRoleTable = this.modelRoleClassName.table;
+    }
     all(roleId) {
-        return ModelRole.query().where('role_id', roleId);
+        return this.modelRoleQuery.where('role_id', roleId);
     }
     async allFor(modelType, roleId) {
-        const map = await morphMap();
-        const modelClass = map.get(modelType);
+        const modelClass = this.map.get(modelType);
         return modelClass
             .query()
-            .join(ModelRole.table + ' as mr', 'mr.model_id', '=', modelClass.table + '.id')
+            .join(this.modelRoleTable + ' as mr', 'mr.model_id', '=', modelClass.table + '.id')
             .where('mr.role_id', roleId)
             .where('mr.model_type', modelType);
     }
     allByPermission(permissionId) {
-        return ModelPermission.query()
+        return this.modelPermissionQuery
             .where('permission_id', permissionId)
             .groupBy(['model_type', 'model_id']);
     }
-    async allByPermissionFor(modelType, permisisonId) {
-        const map = await morphMap();
-        const modelClass = map.get(modelType);
+    async allByPermissionFor(modelType, permissionId) {
+        const modelClass = this.map.get(modelType);
         return modelClass
             .query()
-            .join(ModelPermission.table + ' as mp', 'mp.model_id', '=', modelClass.table + '.id')
-            .where('mp.permission_id', permisisonId)
+            .join(this.modelPermissionTable + ' as mp', 'mp.model_id', '=', modelClass.table + '.id')
+            .where('mp.permission_id', permissionId)
             .where('mp.model_type', modelType);
     }
 }

package/build/src/services/permissions/empty_permission.d.ts

@@ -0,0 +1,8 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+export default class EmptyPermission {
+    private permissionClassName;
+    private permissionQuery;
+    constructor(permissionClassName: typeof BaseModel);
+    delete(permission: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
+    query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+}

package/build/src/services/permissions/empty_permission.js

@@ -0,0 +1,17 @@
+import { getPermissionModelQuery } from '../query_helper.js';
+export default class EmptyPermission {
+    permissionClassName;
+    permissionQuery;
+    constructor(permissionClassName) {
+        this.permissionClassName = permissionClassName;
+        this.permissionQuery = getPermissionModelQuery(this.permissionClassName);
+    }
+    delete(permission) {
+        // get all permissions by slug
+        // if there is permission with allowed false then check if it has `links`
+        return this.permissionQuery.where('slug', permission).delete();
+    }
+    query() {
+        return this.permissionQuery;
+    }
+}

package/build/src/services/permissions/permission_has_model_roles.d.ts

@@ -1,20 +1,24 @@
-import ModelPermission from '../../models/model_permission.js';
-import Permission from '../../models/permission.js';
-import Role from '../../models/role.js';
-import { AclModel } from '../../types.js';
+import { AclModel, MorphInterface, PermissionInterface } from '../../types.js';
 import ModelService from '../model_service.js';
 import RolesService from '../roles/roles_service.js';
 import PermissionsService from './permissions_service.js';
+import { BaseModel } from '@adonisjs/lucid/orm';
 export default class PermissionHasModelRoles {
     private permission;
     private roleService;
     private permissionService;
     private modelService;
-    constructor(permission: Permission, roleService: RolesService, permissionService: PermissionsService, modelService: ModelService);
-    models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof ModelPermission, ModelPermission>;
+    private modelPermissionClassName;
+    private roleClassName;
+    private map;
+    private modelPermissionQuery;
+    private roleQuery;
+    private readonly roleTable;
+    constructor(permission: PermissionInterface, roleService: RolesService, permissionService: PermissionsService, modelService: ModelService, modelPermissionClassName: typeof BaseModel, roleClassName: typeof BaseModel, map: MorphInterface);
+    models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     modelsFor(modelType: string): Promise<any>;
-    roles(): Promise<Role[]>;
+    roles(): Promise<import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     belongsToRole(role: string | number): Promise<boolean>;
-    attachToRole(role: string | number, target?: AclModel | Function): Promise<ModelPermission[]>;
+    attachToRole(role: string | number, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     detachFromRole(role: string | number): Promise<any[]>;
 }

package/build/src/services/permissions/permission_has_model_roles.js

@@ -1,16 +1,29 @@
-import ModelPermission from '../../models/model_permission.js';
-import Role from '../../models/role.js';
-import { destructTarget, morphMap } from '../helper.js';
+import { destructTarget } from '../helper.js';
+import { getModelPermissionModelQuery, getRoleModelQuery } from '../query_helper.js';
 export default class PermissionHasModelRoles {
     permission;
     roleService;
     permissionService;
     modelService;
-    constructor(permission, roleService, permissionService, modelService) {
+    modelPermissionClassName;
+    roleClassName;
+    map;
+    modelPermissionQuery;
+    // private readonly modelPermissionTable
+    roleQuery;
+    roleTable;
+    constructor(permission, roleService, permissionService, modelService, modelPermissionClassName, roleClassName, map) {
         this.permission = permission;
         this.roleService = roleService;
         this.permissionService = permissionService;
         this.modelService = modelService;
+        this.modelPermissionClassName = modelPermissionClassName;
+        this.roleClassName = roleClassName;
+        this.map = map;
+        this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName);
+        // this.modelPermissionTable = this.modelPermissionClassName.table
+        this.roleQuery = getRoleModelQuery(this.roleClassName);
+        this.roleTable = this.roleClassName.table;
     }
     models() {
         return this.modelService.allByPermission(this.permission.getModelId());
@@ -19,48 +32,44 @@ export default class PermissionHasModelRoles {
         return this.modelService.allByPermissionFor(modelType, this.permission.getModelId());
     }
     async roles() {
-        const map = await morphMap();
         return this.roleService
-            .roleModelPermissionQuery(map.getAlias(Role))
+            .roleModelPermissionQuery(this.map.getAlias(this.roleClassName))
             .where('mp.permission_id', this.permission.id);
     }
     async belongsToRole(role) {
-        const map = await morphMap();
         const q = this.roleService
-            .roleModelPermissionQuery(map.getAlias(Role))
+            .roleModelPermissionQuery(this.map.getAlias(this.roleClassName))
             .where('mp.permission_id', this.permission.id);
         if (typeof role === 'string') {
-            q.where(Role.table + '.slug', role);
+            q.where(this.roleTable + '.slug', role);
         }
         else {
-            q.where(Role.table + '.id', role);
+            q.where(this.roleTable + '.id', role);
         }
-        const r = await q.select(Role.table + '.id').limit(1);
+        const r = await q.select(this.roleTable + '.id').limit(1);
         return r.length > 0;
     }
     async attachToRole(role, target) {
         if (typeof role === 'string') {
-            const r = await Role.query().where('slug', role).first();
+            const r = await this.roleQuery.where('slug', role).first();
             if (!r) {
                 throw new Error('Role not found');
             }
             role = r.id;
         }
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.giveAll(map.getAlias(Role), role, [this.permission.slug], entity.targetClass, entity.targetId, true);
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.giveAll(this.map.getAlias(this.roleClassName), role, [this.permission.slug], entity.targetClass, entity.targetId, true);
     }
     async detachFromRole(role) {
         if (typeof role === 'string') {
-            const r = await Role.query().where('slug', role).first();
+            const r = await this.roleQuery.where('slug', role).first();
             if (!r) {
                 throw new Error('Role not found');
             }
             role = r.id;
         }
-        const map = await morphMap();
-        return ModelPermission.query()
-            .where('model_type', map.getAlias(Role))
+        return this.modelPermissionQuery
+            .where('model_type', this.map.getAlias(this.roleClassName))
             .where('model_id', role)
             .delete();
     }