@holoyan/adonisjs-permissions 0.1.0

package/build/src/models/permission.js

@@ -0,0 +1,48 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+import config from '@adonisjs/core/services/config';
+import { MorphMap } from '../decorators.js';
+let Permission = class Permission extends BaseModel {
+    static get table() {
+        return config.get('permissions.permissionsConfig.tables.permissions');
+    }
+    getModelId() {
+        return this.id;
+    }
+};
+__decorate([
+    column({ isPrimary: true })
+], Permission.prototype, "id", void 0);
+__decorate([
+    column()
+], Permission.prototype, "slug", void 0);
+__decorate([
+    column()
+], Permission.prototype, "title", void 0);
+__decorate([
+    column()
+], Permission.prototype, "entityType", void 0);
+__decorate([
+    column()
+], Permission.prototype, "entityId", void 0);
+__decorate([
+    column()
+], Permission.prototype, "allowed", void 0);
+__decorate([
+    column()
+], Permission.prototype, "scope", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], Permission.prototype, "createdAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true, autoUpdate: true })
+], Permission.prototype, "updatedAt", void 0);
+Permission = __decorate([
+    MorphMap(config.get('permissions.permissionsConfig.morphMaps.permissions'))
+], Permission);
+export default Permission;

package/build/src/models/role.d.ts

@@ -0,0 +1,16 @@
+import { DateTime } from 'luxon';
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { AclModelInterface } from '../types.js';
+export default class Role extends BaseModel implements AclModelInterface {
+    static get table(): string;
+    getModelId(): number;
+    id: number;
+    slug: string;
+    title: string;
+    entityType: string;
+    entityId: number | null;
+    scope: number;
+    allowed: boolean;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}

package/build/src/models/role.js

@@ -0,0 +1,48 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseModel, column } from '@adonisjs/lucid/orm';
+import config from '@adonisjs/core/services/config';
+import { MorphMap } from '../decorators.js';
+let Role = class Role extends BaseModel {
+    static get table() {
+        return config.get('permissions.permissionsConfig.tables.roles');
+    }
+    getModelId() {
+        return this.id;
+    }
+};
+__decorate([
+    column({ isPrimary: true })
+], Role.prototype, "id", void 0);
+__decorate([
+    column()
+], Role.prototype, "slug", void 0);
+__decorate([
+    column()
+], Role.prototype, "title", void 0);
+__decorate([
+    column()
+], Role.prototype, "entityType", void 0);
+__decorate([
+    column()
+], Role.prototype, "entityId", void 0);
+__decorate([
+    column()
+], Role.prototype, "scope", void 0);
+__decorate([
+    column()
+], Role.prototype, "allowed", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true })
+], Role.prototype, "createdAt", void 0);
+__decorate([
+    column.dateTime({ autoCreate: true, autoUpdate: true })
+], Role.prototype, "updatedAt", void 0);
+Role = __decorate([
+    MorphMap(config.get('permissions.permissionsConfig.morphMaps.roles'))
+], Role);
+export default Role;

package/build/src/morph_map.d.ts

@@ -0,0 +1,8 @@
+export default class MorphMap {
+    private map;
+    set(alias: string, target: any): void;
+    get(alias: string): any;
+    has(alias: string): boolean;
+    hasTarget(target: any): boolean;
+    getAlias(target: any): string;
+}

package/build/src/morph_map.js

@@ -0,0 +1,33 @@
+export default class MorphMap {
+    map = {};
+    set(alias, target) {
+        this.map[alias] = target;
+    }
+    get(alias) {
+        if (!(alias in this.map)) {
+            throw new Error('morph map not found for ' + alias);
+        }
+        return this.map[alias] || null;
+    }
+    has(alias) {
+        return alias in this.map;
+    }
+    hasTarget(target) {
+        const keys = Object.keys(this.map);
+        for (const key of keys) {
+            if (this.map[key] === target) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getAlias(target) {
+        const keys = Object.keys(this.map);
+        for (const key of keys) {
+            if (target instanceof this.map[key] || target === this.map[key]) {
+                return key;
+            }
+        }
+        throw new Error('Target not found');
+    }
+}

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

@@ -0,0 +1,14 @@
+export default class BaseService {
+    protected formatList(models: (string | number | any)[]): {
+        slugs: string[];
+        ids: number[];
+    };
+    protected formatListStringNumbers(models: (string | number)[]): {
+        slugs: string[];
+        ids: number[];
+    };
+    protected formatStringNumbers(models: string | number | any): {
+        slugs: string[];
+        ids: number[];
+    };
+}

package/build/src/services/base_service.js

@@ -0,0 +1,12 @@
+import { formatList, formatListStringNumbers, formatStringNumbers } from './helper.js';
+export default class BaseService {
+    formatList(models) {
+        return formatList(models);
+    }
+    formatListStringNumbers(models) {
+        return formatListStringNumbers(models);
+    }
+    formatStringNumbers(models) {
+        return formatStringNumbers(models);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { AclModel } from '../types.js';
+export declare function morphMap(): Promise<import("../morph_map.js").default>;
+export declare function formatList(models: (string | number | any)[]): {
+    slugs: string[];
+    ids: number[];
+};
+export declare function formatListStringNumbers(models: (string | number)[]): {
+    slugs: string[];
+    ids: number[];
+};
+export declare function formatStringNumbers(models: string | number | any): {
+    slugs: string[];
+    ids: number[];
+};
+export declare function destructTarget(target?: AclModel | Function): Promise<{
+    targetClass: null;
+    targetId: null;
+} | {
+    targetClass: string;
+    targetId: number | null;
+}>;

package/build/src/services/helper.js

@@ -0,0 +1,69 @@
+import app from '@adonisjs/core/services/app';
+export async function morphMap() {
+    const map = await app.container.make('morphMap');
+    return map;
+}
+export function formatList(models) {
+    let slugs = [];
+    let ids = [];
+    for (let model of models) {
+        if (typeof model === 'string') {
+            slugs.push(model);
+        }
+        else if (typeof model === 'number') {
+            ids.push(model);
+        }
+        else {
+            // @ts-ignore
+            ids.push(model.id);
+        }
+    }
+    return { slugs, ids };
+}
+export function formatListStringNumbers(models) {
+    let slugs = [];
+    let ids = [];
+    for (let model of models) {
+        if (typeof model === 'string') {
+            slugs.push(model);
+        }
+        else {
+            // @ts-ignore
+            ids.push(model);
+        }
+    }
+    return { slugs, ids };
+}
+export function formatStringNumbers(models) {
+    let slugs = [];
+    let ids = [];
+    for (let model of models) {
+        if (typeof model === 'string') {
+            slugs.push(model);
+        }
+        else if (typeof model === 'number') {
+            // @ts-ignore
+            ids.push(model);
+        }
+        else {
+            ids.push(model.id);
+        }
+    }
+    return { slugs, ids };
+}
+export async function destructTarget(target) {
+    if (!target) {
+        return {
+            targetClass: null,
+            targetId: null,
+        };
+    }
+    const map = await morphMap();
+    return {
+        targetClass: map.getAlias(target),
+        targetId: isAclModelInterface(target) ? target.getModelId() : null,
+    };
+}
+function isAclModelInterface(obj) {
+    return typeof obj === 'object' && typeof obj.getModelId === 'function';
+}

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

@@ -0,0 +1,48 @@
+import Permission from '../models/permission.js';
+import Role from '../models/role.js';
+import { AclModel } from '../types.js';
+import PermissionsService from './permissions/permissions_service.js';
+import RolesService from './roles/roles_service.js';
+export declare class ModelHasRolePermissions {
+    private model;
+    private roleService;
+    private permissionsService;
+    constructor(model: AclModel, roleService: RolesService, permissionsService: PermissionsService);
+    roles(): Promise<Role[]>;
+    hasRole(role: string | Role): Promise<boolean>;
+    hasAllRoles(roles: (string | Role)[]): Promise<boolean>;
+    hasAnyRole(roles: (string | Role)[]): Promise<boolean>;
+    assignRole(role: string | Role): Promise<boolean>;
+    revokeRole(role: string | number | Role): Promise<boolean>;
+    revokeAllRoles(roles: (string | number | Role)[]): Promise<boolean>;
+    permissions(includeForbiddens?: boolean): Promise<Permission[]>;
+    globalPermissions(includeForbiddens?: boolean): Promise<Permission[]>;
+    onResourcePermissions(includeForbiddens?: boolean): Promise<Permission[]>;
+    directGlobalPermissions(includeForbiddens?: boolean): Promise<Permission[]>;
+    directResourcePermissions(includeForbiddens?: boolean): Promise<Permission[]>;
+    containsPermission(permisison: string | Permission): Promise<boolean>;
+    containsAllPermissions(permisisons: (string | Permission)[]): Promise<boolean>;
+    containsAnyPermission(permisisons: (string | Permission)[]): Promise<boolean>;
+    containsDirectPermission(permisison: string | Permission): Promise<boolean>;
+    containsAllPermissionsDirectly(permisisons: (string | Permission)[]): Promise<boolean>;
+    containsAnyPermissionDirectly(permisisons: (string | Permission)[]): Promise<boolean>;
+    hasPermission(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissions(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyPermission(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyDirectPermission(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    hasDirectPermission(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissionsDirect(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    can(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
+    canAll(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    canAny(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    assignDirectPermission(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    allow(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    revokePermission(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    revokeAllPermissions(permisisons: string[], target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    flushPermissions(): Promise<any[]>;
+    flush(): Promise<boolean>;
+    forbid(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    forbidAll(permisisons: string[], target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    unforbidAll(permisisons: string[], target?: AclModel | Function): Promise<any[]>;
+    unforbid(permisison: string, target?: AclModel | Function): Promise<any[]>;
+}

package/build/src/services/model_has_role_permissions.js

@@ -0,0 +1,172 @@
+import { destructTarget, formatList, morphMap } from './helper.js';
+export class ModelHasRolePermissions {
+    model;
+    roleService;
+    permissionsService;
+    constructor(model, roleService, permissionsService) {
+        this.model = model;
+        this.roleService = roleService;
+        this.permissionsService = permissionsService;
+    }
+    // roles related section BEGIN
+    async roles() {
+        const map = await morphMap();
+        return this.roleService.all(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);
+    }
+    async hasAllRoles(roles) {
+        const map = await morphMap();
+        return this.roleService.hasAll(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);
+    }
+    async assignRole(role) {
+        const map = await morphMap();
+        return this.roleService.assign(role, map.getAlias(this.model), this.model.getModelId());
+    }
+    revokeRole(role) {
+        return this.revokeAllRoles([role]);
+    }
+    revokeAllRoles(roles) {
+        const { slugs, ids } = formatList(roles);
+        return this.roleService.revokeAll([...slugs, ...ids], this.model);
+    }
+    // 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 globalPermissions(includeForbiddens = false) {
+        const map = await morphMap();
+        return this.permissionsService.global(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    }
+    async onResourcePermissions(includeForbiddens = false) {
+        const map = await morphMap();
+        return this.permissionsService.onResource(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    }
+    async directGlobalPermissions(includeForbiddens = false) {
+        const map = await morphMap();
+        return this.permissionsService.directGlobal(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    }
+    async directResourcePermissions(includeForbiddens = false) {
+        const map = await morphMap();
+        return this.permissionsService.directResource(map.getAlias(this.model), this.model.getModelId(), includeForbiddens);
+    }
+    async containsPermission(permisison) {
+        const map = await morphMap();
+        const result = await this.permissionsService.containsAny(map.getAlias(this.model), this.model.getModelId(), [permisison]);
+        return result;
+    }
+    async containsAllPermissions(permisisons) {
+        const map = await morphMap();
+        const result = await this.permissionsService.containsAll(map.getAlias(this.model), this.model.getModelId(), permisisons);
+        return result;
+    }
+    async containsAnyPermission(permisisons) {
+        const map = await morphMap();
+        const result = await this.permissionsService.containsAny(map.getAlias(this.model), this.model.getModelId(), permisisons);
+        return result;
+    }
+    async containsDirectPermission(permisison) {
+        const map = await morphMap();
+        const result = await this.permissionsService.containsAnyDirect(map.getAlias(this.model), this.model.getModelId(), [permisison]);
+        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;
+    }
+    async containsAnyPermissionDirectly(permisisons) {
+        const map = await morphMap();
+        const result = await this.permissionsService.containsAnyDirect(map.getAlias(this.model), this.model.getModelId(), permisisons);
+        return result;
+    }
+    async hasPermission(permisison, target) {
+        return this.hasAnyPermission([permisison], 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 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 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 hasDirectPermission(permisison, target) {
+        return this.hasAnyDirectPermission([permisison], 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;
+    }
+    can(permisison, target) {
+        return this.hasPermission(permisison, target);
+    }
+    canAll(permisisons, target) {
+        return this.hasAllPermissions(permisisons, target);
+    }
+    canAny(permisisons, target) {
+        return this.hasAnyPermission(permisisons, target);
+    }
+    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);
+    }
+    allow(permisison, target) {
+        return this.assignDirectPermission(permisison, target);
+    }
+    async revokePermission(permisison, target) {
+        return this.revokeAllPermissions([permisison], 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 flushPermissions() {
+        const map = await morphMap();
+        return this.permissionsService.flush(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());
+        return true;
+    }
+    async forbid(permisison, target) {
+        return this.forbidAll([permisison], 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 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 unforbid(permisison, target) {
+        return this.unforbidAll([permisison], target);
+    }
+}

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

@@ -0,0 +1,8 @@
+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>;
+    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>;
+}

package/build/src/services/model_service.js

@@ -0,0 +1,31 @@
+import ModelPermission from '../models/model_permission.js';
+import ModelRole from '../models/model_role.js';
+import { morphMap } from './helper.js';
+export default class ModelService {
+    all(roleId) {
+        return ModelRole.query().where('role_id', roleId);
+    }
+    async allFor(modelType, roleId) {
+        const map = await morphMap();
+        const modelClass = map.get(modelType);
+        return modelClass
+            .query()
+            .join(ModelRole.table + ' as mr', 'mr.model_id', '=', modelClass.table + '.id')
+            .where('mr.role_id', roleId)
+            .where('mr.model_type', modelType);
+    }
+    allByPermission(permissionId) {
+        return ModelPermission.query()
+            .where('permission_id', permissionId)
+            .groupBy(['model_type', 'model_id']);
+    }
+    async allByPermissionFor(modelType, permisisonId) {
+        const map = await morphMap();
+        const modelClass = map.get(modelType);
+        return modelClass
+            .query()
+            .join(ModelPermission.table + ' as mp', 'mp.model_id', '=', modelClass.table + '.id')
+            .where('mp.permission_id', permisisonId)
+            .where('mp.model_type', modelType);
+    }
+}

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

@@ -0,0 +1,20 @@
+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 ModelService from '../model_service.js';
+import RolesService from '../roles/roles_service.js';
+import PermissionsService from './permissions_service.js';
+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>;
+    modelsFor(modelType: string): Promise<any>;
+    roles(): Promise<Role[]>;
+    belongsToRole(role: string | number): Promise<boolean>;
+    attachToRole(role: string | number, target?: AclModel | Function): Promise<ModelPermission[]>;
+    detachFromRole(role: string | number): Promise<any[]>;
+}

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

@@ -0,0 +1,67 @@
+import ModelPermission from '../../models/model_permission.js';
+import Role from '../../models/role.js';
+import { destructTarget, morphMap } from '../helper.js';
+export default class PermissionHasModelRoles {
+    permission;
+    roleService;
+    permissionService;
+    modelService;
+    constructor(permission, roleService, permissionService, modelService) {
+        this.permission = permission;
+        this.roleService = roleService;
+        this.permissionService = permissionService;
+        this.modelService = modelService;
+    }
+    models() {
+        return this.modelService.allByPermission(this.permission.getModelId());
+    }
+    modelsFor(modelType) {
+        return this.modelService.allByPermissionFor(modelType, this.permission.getModelId());
+    }
+    async roles() {
+        const map = await morphMap();
+        return this.roleService
+            .roleModelPermissionQuery(map.getAlias(Role))
+            .where('mp.permission_id', this.permission.id);
+    }
+    async belongsToRole(role) {
+        const map = await morphMap();
+        const q = this.roleService
+            .roleModelPermissionQuery(map.getAlias(Role))
+            .where('mp.permission_id', this.permission.id);
+        if (typeof role === 'string') {
+            q.where(Role.table + '.slug', role);
+        }
+        else {
+            q.where(Role.table + '.id', role);
+        }
+        const r = await q.select(Role.table + '.id').limit(1);
+        return r.length > 0;
+    }
+    async attachToRole(role, target) {
+        if (typeof role === 'string') {
+            const r = await Role.query().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);
+    }
+    async detachFromRole(role) {
+        if (typeof role === 'string') {
+            const r = await Role.query().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))
+            .where('model_id', role)
+            .delete();
+    }
+}