@holoyan/adonisjs-permissions 0.1.0 → 0.5.2

package/build/src/services/roles/empty_roles.js

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

package/build/src/services/roles/role_has_model_permissions.d.ts

@@ -1,66 +1,65 @@
-import Permission from '../../models/permission.js';
-import Role from '../../models/role.js';
 import ModelService from '../model_service.js';
 import PermissionsService from '../permissions/permissions_service.js';
-import { AclModel } from '../../types.js';
+import { AclModel, MorphInterface, PermissionInterface, RoleInterface } from '../../types.js';
 export declare class RoleHasModelPermissions {
     private role;
     private permissionService;
     private modelService;
-    constructor(role: Role, permissionService: PermissionsService, modelService: ModelService);
-    models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof import("../../models/model_role.js").default, import("../../models/model_role.js").default>;
+    private map;
+    constructor(role: RoleInterface, permissionService: PermissionsService, modelService: ModelService, map: MorphInterface);
+    models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     modelsFor(modelType: string): Promise<any>;
     /**
      * todo
      * @param model
      */
-    permissions(): Promise<Permission[]>;
-    globalPermissions(): Promise<Permission[]>;
-    onResourcePermissions(): Promise<Permission[]>;
-    containsPermission(permisison: string | Permission): Promise<boolean>;
+    permissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    globalPermissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    onResourcePermissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    containsPermission(permission: string | PermissionInterface): Promise<boolean>;
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    containsAllPermissions(permisisons: (string | Permission)[]): Promise<boolean>;
+    containsAllPermissions(permissions: (string | PermissionInterface)[]): Promise<boolean>;
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    containsAnyPermissions(permisisons: (string | Permission)[]): Promise<boolean>;
-    hasPermission(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
+    containsAnyPermissions(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    hasPermission(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    hasAllPermissions(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissions(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    hasAnyPermissions(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyPermissions(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
     /**
      *
-     * @param permisison
+     * @param permission
      * @returns
      */
-    can(permisison: string | Permission): Promise<boolean>;
-    canAll(permisisons: (string | Permission)[]): Promise<boolean>;
-    canAny(permisisons: (string | Permission)[]): Promise<boolean>;
-    forbidden(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
-    assign(permisison: string, target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    give(permisison: string, target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    giveAll(permisisons: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    assingAll(permisisons: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    revokePermission(permisison: string): Promise<import("../../models/model_permission.js").default[]>;
-    revoke(permisison: string): Promise<import("../../models/model_permission.js").default[]>;
-    revokeAll(permisisons: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    revokeAllPermissions(permisisons: string[]): Promise<import("../../models/model_permission.js").default[]>;
+    can(permission: string | PermissionInterface): Promise<boolean>;
+    canAll(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    canAny(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    forbidden(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
+    assign(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    give(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    giveAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    assingAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    revokePermission(permission: string): Promise<any[]>;
+    revoke(permission: string): Promise<any[]>;
+    revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+    revokeAllPermissions(permissions: string[]): Promise<any[]>;
     flush(): Promise<any[]>;
-    forbid(permisison: string, target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
-    unforbid(permisison: string, target?: AclModel | Function): Promise<any[]>;
+    forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
 }

package/build/src/services/roles/role_has_model_permissions.js

@@ -1,12 +1,14 @@
-import { destructTarget, morphMap } from '../helper.js';
+import { destructTarget } from '../helper.js';
 export class RoleHasModelPermissions {
     role;
     permissionService;
     modelService;
-    constructor(role, permissionService, modelService) {
+    map;
+    constructor(role, permissionService, modelService, map) {
         this.role = role;
         this.permissionService = permissionService;
         this.modelService = modelService;
+        this.map = map;
     }
     models() {
         return this.modelService.all(this.role.getModelId());
@@ -22,131 +24,115 @@ export class RoleHasModelPermissions {
     // permissions related BEGIN
     async permissions() {
         // for roles direct and all permissions are same
-        const map = await morphMap();
-        return this.permissionService.direct(map.getAlias(this.role), this.role.getModelId());
+        return this.permissionService.direct(this.map.getAlias(this.role), this.role.getModelId());
     }
     async globalPermissions() {
-        const map = await morphMap();
-        return this.permissionService.directGlobal(map.getAlias(this.role), this.role.getModelId());
+        return this.permissionService.directGlobal(this.map.getAlias(this.role), this.role.getModelId());
     }
     async onResourcePermissions() {
-        const map = await morphMap();
-        return this.permissionService.directResource(map.getAlias(this.role), this.role.getModelId());
+        return this.permissionService.directResource(this.map.getAlias(this.role), this.role.getModelId());
     }
-    async containsPermission(permisison) {
-        const map = await morphMap();
-        const result = await this.permissionService.containsAny(map.getAlias(this.role), this.role.getModelId(), [permisison]);
+    async containsPermission(permission) {
+        const result = await this.permissionService.containsAny(this.map.getAlias(this.role), this.role.getModelId(), [permission]);
         return result;
     }
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    async containsAllPermissions(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionService.containsAll(map.getAlias(this.role), this.role.getModelId(), permisisons);
+    async containsAllPermissions(permissions) {
+        const result = await this.permissionService.containsAll(this.map.getAlias(this.role), this.role.getModelId(), permissions);
         return result;
     }
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    async containsAnyPermissions(permisisons) {
-        const map = await morphMap();
-        const result = await this.permissionService.containsAny(map.getAlias(this.role), this.role.getModelId(), permisisons);
+    async containsAnyPermissions(permissions) {
+        const result = await this.permissionService.containsAny(this.map.getAlias(this.role), this.role.getModelId(), permissions);
         return result;
     }
-    async hasPermission(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionService.hasAny(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId);
+    async hasPermission(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        const result = await this.permissionService.hasAny(this.map.getAlias(this.role), this.role.getModelId(), [permission], entity.targetClass, entity.targetId);
         return result;
     }
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    async hasAllPermissions(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionService.hasAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async hasAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const result = await this.permissionService.hasAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
         return result;
     }
     /**
      *
-     * @param permisisons
+     * @param permissions
      * @returns
      */
-    async hasAnyPermissions(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        const result = await this.permissionService.hasAny(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async hasAnyPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const result = await this.permissionService.hasAny(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
         return result;
     }
     /**
      *
-     * @param permisison
+     * @param permission
      * @returns
      */
-    can(permisison) {
-        return this.hasPermission(permisison);
+    can(permission) {
+        return this.hasPermission(permission);
     }
-    canAll(permisisons) {
-        return this.hasAllPermissions(permisisons);
+    canAll(permissions) {
+        return this.hasAllPermissions(permissions);
     }
-    canAny(permisisons) {
-        return this.hasAnyPermissions(permisisons);
+    canAny(permissions) {
+        return this.hasAnyPermissions(permissions);
     }
-    async forbidden(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.forbidden(map.getAlias(this.role), this.role.getModelId(), permisison, entity.targetClass, entity.targetId);
+    async forbidden(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.forbidden(this.map.getAlias(this.role), this.role.getModelId(), permission, entity.targetClass, entity.targetId);
     }
-    assign(permisison, target) {
-        return this.give(permisison, target);
+    assign(permission, target) {
+        return this.give(permission, target);
     }
-    async give(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.giveAll(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId, true);
+    async give(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), [permission], entity.targetClass, entity.targetId, true);
     }
-    async giveAll(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.giveAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId, true);
+    async giveAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId, true);
     }
-    assingAll(permisisons, target) {
-        return this.giveAll(permisisons, target);
+    assingAll(permissions, target) {
+        return this.giveAll(permissions, target);
     }
-    async revokePermission(permisison) {
-        return this.revoke(permisison);
+    async revokePermission(permission) {
+        return this.revoke(permission);
     }
-    async revoke(permisison) {
-        return this.revokeAll([permisison]);
+    async revoke(permission) {
+        return this.revokeAll([permission]);
     }
-    async revokeAll(permisisons, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.revokeAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    async revokeAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.revokeAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
-    async revokeAllPermissions(permisisons) {
-        return this.revokeAll(permisisons);
+    async revokeAllPermissions(permissions) {
+        return this.revokeAll(permissions);
     }
     async flush() {
-        const map = await morphMap();
-        return this.permissionService.flush(map.getAlias(this.role), this.role.getModelId());
-    }
-    async forbid(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.forbid(map.getAlias(this.role), this.role.getModelId(), permisison, entity.targetClass, entity.targetId);
-    }
-    async unforbid(permisison, target) {
-        const map = await morphMap();
-        const entity = await destructTarget(target);
-        return this.permissionService.unforbidAll(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId);
+        return this.permissionService.flush(this.map.getAlias(this.role), this.role.getModelId());
+    }
+    async forbid(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.forbid(this.map.getAlias(this.role), this.role.getModelId(), permission, entity.targetClass, entity.targetId);
+    }
+    async unforbid(permission, target) {
+        const entity = await destructTarget(this.map, target);
+        return this.permissionService.unforbidAll(this.map.getAlias(this.role), this.role.getModelId(), [permission], entity.targetClass, entity.targetId);
     }
 }

package/build/src/services/roles/roles_service.d.ts

@@ -1,16 +1,27 @@
-import Role from '../../models/role.js';
-import { AclModel } from '../../types.js';
+import { AclModel, MorphInterface, RoleInterface } from '../../types.js';
 import BaseService from '../base_service.js';
+import { BaseModel } from '@adonisjs/lucid/orm';
 export default class RolesService extends BaseService {
+    private roleClassName;
+    private modelPermissionClassName;
+    private modelRoleClassName;
+    private map;
+    private roleQuery;
+    private readonly roleTable;
+    private readonly modelPermissionTable;
+    private modelRoleQuery;
+    private readonly modelRoleTable;
+    constructor(roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
     private modelRolesQuery;
-    all(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof Role, Role>;
-    has(modelType: string, modelId: number, role: string | Role): Promise<boolean>;
-    hasAll(modelType: string, modelId: number, roles: (string | Role)[]): Promise<boolean>;
-    hasAny(modelType: string, modelId: number, roles: (string | Role)[]): Promise<boolean>;
-    assign(role: string | Role, modelType: string, modelId: number): Promise<boolean>;
+    all(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    has(modelType: string, modelId: number, role: string | RoleInterface): Promise<boolean>;
+    hasAll(modelType: string, modelId: number, roles: (string | RoleInterface)[]): Promise<boolean>;
+    hasAny(modelType: string, modelId: number, roles: (string | RoleInterface)[]): Promise<boolean>;
+    assign(role: string | RoleInterface, modelType: string, modelId: number): Promise<boolean>;
+    assignAll(roles: (string | RoleInterface)[], modelType: string, modelId: number): Promise<boolean>;
     revoke(role: string | number, model: AclModel): Promise<boolean>;
     revokeAll(roles: (string | number)[], model: AclModel): Promise<boolean>;
     private extractRoleModel;
-    roleModelPermissionQuery(modelType: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof Role, Role>;
-    flush(modelType: string, modelId: number): Promise<void>;
+    roleModelPermissionQuery(modelType: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    flush(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
 }

package/build/src/services/roles/roles_service.js

@@ -1,33 +1,65 @@
-import Role from '../../models/role.js';
-import ModelRole from '../../models/model_role.js';
 import BaseService from '../base_service.js';
-import ModelPermission from '../../models/model_permission.js';
-import { morphMap } from '../helper.js';
+import { 
+// getModelPermissionModelQuery,
+getModelRoleModelQuery, 
+// getPermissionModelQuery,
+getRoleModelQuery, } from '../query_helper.js';
 export default class RolesService extends BaseService {
+    roleClassName;
+    modelPermissionClassName;
+    modelRoleClassName;
+    map;
+    // private permissionQuery
+    // private readonly permissionTable
+    roleQuery;
+    roleTable;
+    // private modelPermissionQuery
+    modelPermissionTable;
+    modelRoleQuery;
+    modelRoleTable;
+    constructor(roleClassName, 
+    // private permissionClassName: typeof BaseModel,
+    modelPermissionClassName, modelRoleClassName, map) {
+        super();
+        this.roleClassName = roleClassName;
+        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;
+    }
     modelRolesQuery(modelType, modelId) {
-        return Role.query()
-            .join(ModelRole.table + ' as mr', 'mr.role_id', '=', Role.table + '.id')
+        return this.roleQuery
+            .leftJoin(this.modelRoleTable + ' as mr', 'mr.role_id', '=', this.roleTable + '.id')
             .where('mr.model_type', modelType)
             .where('mr.model_id', modelId);
     }
     all(modelType, modelId) {
-        return this.modelRolesQuery(modelType, modelId).select(Role.table + '.*');
+        return this.modelRolesQuery(modelType, modelId)
+            .distinct(this.roleTable + '.id')
+            .select(this.roleTable + '.*');
     }
-    async has(modelType, modelId, role) {
+    has(modelType, modelId, role) {
         return this.hasAll(modelType, modelId, [role]);
     }
     async hasAll(modelType, modelId, roles) {
         const rolesQuery = this.modelRolesQuery(modelType, modelId);
         let { slugs, ids } = this.formatList(roles);
         if (slugs.length) {
-            rolesQuery.whereIn(Role.table + '.slug', slugs);
+            rolesQuery.whereIn(this.roleTable + '.slug', slugs);
         }
         if (ids.length) {
-            rolesQuery.whereIn(Role.table + '.id', ids);
+            rolesQuery.whereIn(this.roleTable + '.id', ids);
         }
         const r = await rolesQuery.count('* as total');
         // @ts-ignore
-        return r[0].total === roles.length;
+        return +r[0].$extras.total === roles.length;
     }
     async hasAny(modelType, modelId, roles) {
         // if is string then we are going to check against slug
@@ -35,36 +67,52 @@ export default class RolesService extends BaseService {
         const rolesQuery = this.modelRolesQuery(modelType, modelId);
         let { slugs, ids } = this.formatList(roles);
         if (slugs.length) {
-            rolesQuery.whereIn(Role.table + '.slug', slugs);
+            rolesQuery.whereIn(this.roleTable + '.slug', slugs);
         }
         if (ids.length) {
-            rolesQuery.whereIn(Role.table + '.id', ids);
+            rolesQuery.whereIn(this.roleTable + '.id', ids);
         }
         const r = await rolesQuery.count('* as total');
         // @ts-ignore
-        return r[0].total > 0;
+        return +r[0].$extras.total > 0;
+    }
+    assign(role, modelType, modelId) {
+        return this.assignAll([role], modelType, modelId);
     }
-    async assign(role, modelType, modelId) {
-        const r = await this.extractRoleModel(role);
-        if (!r) {
-            throw new Error('Role  not found');
+    async assignAll(roles, modelType, modelId) {
+        const rs = await this.extractRoleModel(roles);
+        if (!rs.length) {
+            throw new Error('One or many roles not found');
         }
-        await ModelRole.create({
-            modelType,
-            modelId,
-            roleId: r.id,
+        let roleIds = rs.map((role) => role.id);
+        const modelRoles = await this.modelRoleQuery
+            .whereIn('role_id', roleIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const modelRoleIds = modelRoles.map((modelRole) => modelRole.id);
+        roleIds = roleIds.filter((roleId) => {
+            return !modelRoleIds.includes(roleId);
         });
+        const data = [];
+        for (const id of roleIds) {
+            data.push({
+                modelType,
+                modelId,
+                roleId: id,
+            });
+        }
+        await this.modelRoleClassName.createMany(data);
         return true;
     }
     async revoke(role, model) {
         return this.revokeAll([role], model);
     }
     async revokeAll(roles, model) {
-        const map = await morphMap();
         const { slugs, ids } = this.formatListStringNumbers(roles);
-        await ModelRole.query()
-            .leftJoin(Role.table + ' as r', 'r.id', '=', ModelRole.table + '.role_id')
-            .where('model_type', map.getAlias(model))
+        await this.modelRoleQuery
+            .leftJoin(this.roleTable + ' as r', 'r.id', '=', this.modelRoleTable + '.role_id')
+            .where('model_type', this.map.getAlias(model))
             .where('model_id', model.getModelId())
             .where((query) => {
             query.whereIn('r.id', ids).orWhereIn('r.slug', slugs);
@@ -72,18 +120,26 @@ export default class RolesService extends BaseService {
             .delete();
         return true;
     }
-    async extractRoleModel(role) {
-        if (typeof role === 'string') {
-            return await Role.query().where('slug', role).first();
+    async extractRoleModel(roles) {
+        const slugs = [];
+        const oldRoles = [];
+        for (const role of roles) {
+            if (typeof role === 'string') {
+                slugs.push(role);
+            }
+            else {
+                oldRoles.push(role);
+            }
         }
-        return role;
+        const newRoles = await this.roleQuery.whereIn('slug', slugs);
+        return [...newRoles, ...oldRoles];
     }
     roleModelPermissionQuery(modelType) {
-        return Role.query()
-            .leftJoin(ModelPermission.table + ' as mp', 'mp.model_id', '=', Role.table + '.id')
+        return this.roleQuery
+            .leftJoin(this.modelPermissionTable + ' as mp', 'mp.model_id', '=', this.roleTable + '.id')
             .where('mp.model_type', modelType);
     }
-    async flush(modelType, modelId) {
-        ModelRole.query().where('model_type', modelType).where('model_id', modelId).delete();
+    flush(modelType, modelId) {
+        return this.modelRoleQuery.where('model_type', modelType).where('model_id', modelId).delete();
     }
 }

package/build/src/types.d.ts

@@ -1,21 +1,81 @@
 import { LucidModel } from '@adonisjs/lucid/types/model';
-export interface Permissions {
-    tables: Object;
-}
+import { DateTime } from 'luxon';
 export interface AclModelInterface {
     getModelId(): number;
 }
-export type AclModel = LucidModel & AclModelInterface;
+export interface PermissionInterface extends AclModelInterface {
+    id: number;
+    slug: string;
+    title: string | null;
+    entityType: string;
+    entityId: number | null;
+    allowed: boolean;
+    scope: number;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+export interface RoleInterface extends AclModelInterface {
+    id: number;
+    slug: string;
+    title: string | null;
+    entityType: string;
+    entityId: number | null;
+    scope: number;
+    allowed: boolean;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+export interface ModelRoleInterface extends AclModelInterface {
+    id: number;
+    roleId: number;
+    modelType: string;
+    modelId: number | null;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+export interface ModelPermissionInterface extends AclModelInterface {
+    id: number;
+    permissionId: number;
+    modelType: string;
+    modelId: number;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+export type AclModel = InstanceType<LucidModel> & AclModelInterface;
+export type PermissionModel<T extends new (...args: any[]) => any> = InstanceType<T> & PermissionInterface;
+export type RoleModel<T extends new (...args: any[]) => any> = InstanceType<T> & RoleInterface;
+export type ModelPermissionModel<T extends new (...args: any[]) => any> = InstanceType<T> & ModelPermissionInterface;
+export type ModelRoleModel<T extends new (...args: any[]) => any> = InstanceType<T> & ModelRoleInterface;
 export interface AclModelQuery {
     modelType: string;
     modelId: number;
 }
+type Entity = {
+    type: string | null;
+    id: number | null;
+};
 export interface ModelPermissionsQuery extends AclModelQuery {
     permissionSlugs: string[];
     permissionIds: number[];
     directPermissions: boolean;
-    includeForbiddens: boolean;
+    includeForbiddings: boolean;
+    entity: Entity;
 }
 export interface MorphMapInterface {
     [key: string]: any;
 }
+export interface MorphInterface {
+    set(alias: string, target: any): void;
+    get(alias: string): any;
+    has(alias: string): boolean;
+    hasTarget(target: any): boolean;
+    getAlias(target: any): string;
+}
+export interface ModelManagerInterface {
+    [key: string]: LucidModel;
+}
+export interface Permissions {
+    tables: Object;
+    morphMaps: Object;
+}
+export {};

package/build/stubs/configs/permissions.stub

@@ -16,5 +16,5 @@ export const permissionsConfig: Permissions = {
   morphMaps: {
     roles: 'roles',
     permissions: 'permissions',
-  }
+  },
 }