@holoyan/adonisjs-permissions 0.1.0 → 0.5.2

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

@@ -1,234 +1,270 @@
-import ModelPermission from '../../models/model_permission.js';
-import ModelRole from '../../models/model_role.js';
-import Permission from '../../models/permission.js';
-import Role from '../../models/role.js';
 import BaseService from '../base_service.js';
-import { morphMap } from '../helper.js';
+import { getModelPermissionModelQuery, getPermissionModelQuery } from '../query_helper.js';
 export default class PermissionsService extends BaseService {
+    permissionClassName;
+    roleClassName;
+    modelPermissionClassName;
+    modelRoleClassName;
+    map;
+    permissionQuery;
+    permissionTable;
+    // private roleQuery
+    // private readonly roleTable
+    modelPermissionQuery;
+    modelPermissionTable;
+    // private modelRoleQuery
+    modelRoleTable;
+    constructor(permissionClassName, roleClassName, modelPermissionClassName, modelRoleClassName, map) {
+        super();
+        this.permissionClassName = permissionClassName;
+        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;
+    }
     /**
-     * return all permissions, including fodbidden
+     * return all permissions, including forbidden
      */
-    async all(modelType, modelId, includeForbiddens = false) {
-        const map = await morphMap();
-        return this.modelPermissionQuery({
+    async all(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
-            includeForbiddens,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
+            includeForbiddings,
         })
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
     /**
      * return only global assigned permissions, through role or direct
      */
-    async global(modelType, modelId, includeForbiddens = false) {
-        const map = await morphMap();
-        return this.modelPermissionQuery({
+    async global(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
-            includeForbiddens,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
+            includeForbiddings,
         })
-            .where(Permission.table + '.entity_type', '*')
-            .whereNull(Permission.table + '.entity_id')
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .where(this.permissionTable + '.entity_type', '*')
+            .whereNull(this.permissionTable + '.entity_id')
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
     /**
      * get all permissions which is assigned to concrete resource
      */
-    async onResource(modelType, modelId, includeForbiddens = false) {
-        const map = await morphMap();
-        return this.modelPermissionQuery({
+    async onResource(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
-            includeForbiddens,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
+            includeForbiddings,
         })
-            .where(Permission.table + '.entity_type', '!=', '*')
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .where(this.permissionTable + '.entity_type', '!=', '*')
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
     /**
      * all direct permissions
      */
-    direct(modelType, modelId, includeForbiddens = false) {
-        return this.modelPermissionQuery({
+    direct(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
             directPermissions: true,
-            includeForbiddens,
+            includeForbiddings,
         })
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
-    directGlobal(modelType, modelId, includeForbiddens = false) {
-        return this.modelPermissionQuery({
+    directGlobal(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
             directPermissions: true,
-            includeForbiddens,
+            includeForbiddings,
         })
-            .whereNull(Permission.table + '.entity_id')
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .whereNull(this.permissionTable + '.entity_id')
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
     /**
      * return direct and resource assigned permissions
      */
-    directResource(modelType, modelId, includeForbiddens = false) {
-        return this.modelPermissionQuery({
+    directResource(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
             modelType,
             modelId,
             directPermissions: true,
-            includeForbiddens,
+            includeForbiddings,
         })
-            .whereNotNull(Permission.table + '.entity_id')
-            .groupBy(Permission.table + '.id')
-            .select(Permission.table + '.*');
+            .whereNotNull(this.permissionTable + '.entity_id')
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
     }
     /**
      * @param modelType
      * @param modelId
-     * @param permisison
+     * @param permissions
+     * @param entityType
+     * @param entityId
      * @returns
      */
-    async hasAnyDirect(modelType, modelId, permisisons, entityType, entityId) {
-        const { slugs, ids } = this.formatList(permisisons);
+    async hasAnyDirect(modelType, modelId, permissions, entityType, entityId) {
+        const { slugs, ids } = this.formatList(permissions);
         const q = this.modelPermissionQueryWithForbiddenCheck({
             modelType,
             modelId,
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
+            entity: {
+                type: entityType,
+                id: entityId,
+            },
         });
-        this.applyTargetRestriction(q, entityType, entityId);
-        const r = await q.groupBy(Permission.table + '.id').select(Permission.table + '.id');
+        this.applyTargetRestriction(this.permissionTable, q, entityType, entityId);
+        const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
         return r.length > 0;
     }
-    async hasAllDirect(modelType, modelId, permisisons, entityType, entityId) {
-        const { slugs, ids } = this.formatList(permisisons);
+    async hasAllDirect(modelType, modelId, permissions, entityType, entityId) {
+        const { slugs, ids } = this.formatList(permissions);
         const q = this.modelPermissionQueryWithForbiddenCheck({
             modelType,
             modelId,
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
+            entity: {
+                type: entityType,
+                id: entityId,
+            },
         });
-        this.applyTargetRestriction(q, entityType, entityId);
-        const r = await q.groupBy(Permission.table + '.id').select(Permission.table + '.id');
-        return r.length >= permisisons.length;
+        this.applyTargetRestriction(this.permissionTable, q, entityType, entityId);
+        const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
+        return r.length >= permissions.length;
     }
     /**
      * has all permissions
      */
-    async hasAll(modelType, modelId, permisisons, entityType, entityId) {
-        const map = await morphMap();
-        const { slugs, ids } = this.formatList(permisisons);
+    async hasAll(modelType, modelId, permissions, entityType, entityId) {
+        const { slugs, ids } = this.formatList(permissions);
         const q = this.modelPermissionQueryWithForbiddenCheck({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
             permissionSlugs: slugs,
             permissionIds: ids,
+            entity: {
+                type: entityType,
+                id: entityId,
+            },
         });
-        this.applyTargetRestriction(q, entityType, entityId);
-        const r = await q.groupBy(Permission.table + '.id').select(Permission.table + '.id');
-        return r.length >= permisisons.length;
+        this.applyTargetRestriction(this.permissionTable, q, entityType, entityId);
+        const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
+        return r.length >= permissions.length;
     }
     /**
      * has any of permissions
      */
-    async hasAny(modelType, modelId, permisison, entityType, entityId) {
-        const map = await morphMap();
-        const { slugs, ids } = this.formatList(permisison);
+    async hasAny(modelType, modelId, permission, entityType, entityId) {
+        const { slugs, ids } = this.formatList(permission);
         const q = this.modelPermissionQueryWithForbiddenCheck({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
             permissionSlugs: slugs,
             permissionIds: ids,
+            entity: {
+                type: entityType,
+                id: entityId,
+            },
         });
-        this.applyTargetRestriction(q, entityType, entityId);
-        const r = await q.groupBy(Permission.table + '.id').select(Permission.table + '.id');
+        this.applyTargetRestriction(this.permissionTable, q, entityType, entityId);
+        const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
         return r.length > 0;
     }
     /**
      * has all permissions
      */
-    async containsAll(modelType, modelId, permisison) {
-        const map = await morphMap();
-        const { slugs, ids } = this.formatList(permisison);
-        const q = this.modelPermissionQuery({
+    async containsAll(modelType, modelId, permission) {
+        const { slugs, ids } = this.formatList(permission);
+        const q = this.modelPermissionQueryBuilder({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
             permissionSlugs: slugs,
             permissionIds: ids,
-        }).groupBy(Permission.table + '.id');
-        const r = await q.select(Permission.table + '.id');
-        return r.length >= permisison.length;
+        }).distinct(this.permissionTable + '.id');
+        const r = await q.select(this.permissionTable + '.id');
+        return r.length >= permission.length;
     }
     /**
      * has any of permissions
      */
-    async containsAny(modelType, modelId, permisison) {
-        const map = await morphMap();
-        const { slugs, ids } = this.formatList(permisison);
-        const q = this.modelPermissionQuery({
+    async containsAny(modelType, modelId, permission) {
+        const { slugs, ids } = this.formatList(permission);
+        const q = this.modelPermissionQueryBuilder({
             modelType,
             modelId,
-            directPermissions: map.getAlias(Role) === modelType,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
             permissionSlugs: slugs,
             permissionIds: ids,
-        }).groupBy(Permission.table + '.id');
-        const r = await q.select(Permission.table + '.id');
+        }).distinct(this.permissionTable + '.id');
+        const r = await q.select(this.permissionTable + '.id');
         // @ts-ignore
         return r.length > 0;
     }
     /**
      * has all permissions
      */
-    async containsAllDirect(modelType, modelId, permisison) {
-        const { slugs, ids } = this.formatList(permisison);
-        const q = this.modelPermissionQuery({
+    async containsAllDirect(modelType, modelId, permission) {
+        const { slugs, ids } = this.formatList(permission);
+        const q = this.modelPermissionQueryBuilder({
             modelType,
             modelId,
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
-        }).groupBy(Permission.table + '.id');
-        const r = await q.select(Permission.table + '.id');
-        return r.length >= permisison.length;
+        }).distinct(this.permissionTable + '.id');
+        const r = await q.select(this.permissionTable + '.id');
+        return r.length >= permission.length;
     }
     /**
      * has any of permissions
      */
-    async containsAnyDirect(modelType, modelId, permisison) {
-        const { slugs, ids } = this.formatList(permisison);
-        const q = this.modelPermissionQuery({
+    async containsAnyDirect(modelType, modelId, permission) {
+        const { slugs, ids } = this.formatList(permission);
+        const q = this.modelPermissionQueryBuilder({
             modelType,
             modelId,
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
-        }).groupBy(Permission.table + '.id');
-        const r = await q.select(Permission.table + '.id');
+        }).distinct(this.permissionTable + '.id');
+        const r = await q.select(this.permissionTable + '.id');
         // @ts-ignore
         return r.length > 0;
     }
     /**
      * check if permission is forbidden, if there is same permission with allowed=false then return true;
      */
-    forbidden(modelType, modelId, permisison, entityType, entityId) {
-        return !this.hasAny(modelType, modelId, [permisison], entityType, entityId);
+    forbidden(modelType, modelId, permission, entityType, entityId) {
+        return !this.hasAny(modelType, modelId, [permission], entityType, entityId);
     }
     /**
      * give permission to model
      */
     async giveAll(modelType, modelId, slugs, entityType, entityId, allowed) {
-        // if entityType is not null then we need to assigne permission for specific entity
+        // if entityType is not null then we need to assign permission for specific entity
         let permissions = await this.findAssignableEntity(slugs, entityType, entityId, allowed);
         //if no permissions then we will create permission for this specific entity
         let createManyData = [];
@@ -239,7 +275,7 @@ export default class PermissionsService extends BaseService {
                 createManyData.push({
                     slug,
                     title: slug,
-                    entityType,
+                    entityType: entityType || '*',
                     entityId,
                     allowed,
                 });
@@ -249,44 +285,56 @@ export default class PermissionsService extends BaseService {
             }
         }
         if (createManyData.length) {
-            const newPermissions = await Permission.createMany(createManyData);
+            const newPermissions = (await this.permissionClassName.createMany(createManyData));
             newPermissions.map((i) => permissionIds.push(i.id));
         }
+        // first check if there are assigned or not
+        const alreadyAssigned = await this.modelPermissionQuery
+            .whereIn('id', permissionIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const alreadyAssignedIds = alreadyAssigned.map((item) => item.id);
+        permissionIds = permissionIds.filter((item) => {
+            return !alreadyAssignedIds.includes(item);
+        });
         let modelPermissionMany = permissionIds.map((i) => ({
             modelType: modelType,
             modelId: modelId,
             permissionId: i,
         }));
-        return ModelPermission.createMany(modelPermissionMany);
+        return this.modelPermissionClassName.createMany(modelPermissionMany);
     }
     revokeAll(modelType, modelId, permissions, entityType, entityId) {
-        const q = ModelPermission.query()
-            .leftJoin(Permission.table + ' as p', 'p.id', '=', ModelPermission.table + '.permission_id')
+        const q = this.modelPermissionQuery
+            .leftJoin(this.permissionTable + ' as p', 'p.id', '=', this.modelPermissionTable + '.permission_id')
             .whereIn('p.slug', permissions)
             .where('p.allowed', true)
-            .where(ModelPermission.table + '.model_type', modelType)
-            .where(ModelPermission.table + '.model_id', modelId);
+            .where(this.modelPermissionTable + '.model_type', modelType)
+            .where(this.modelPermissionTable + '.model_id', modelId);
         if (entityType) {
             q.where('p.entity_type', entityType);
             if (entityId) {
                 q.where('p.entity_id', entityId);
             }
         }
-        return q;
+        return q.delete();
     }
     flush(modelType, modelId) {
-        return ModelPermission.query()
-            .where(ModelPermission.table + '.model_type', modelType)
-            .where(ModelPermission.table + '.model_id', modelId)
+        return this.modelPermissionQuery
+            .where(this.modelPermissionTable + '.model_type', modelType)
+            .where(this.modelPermissionTable + '.model_id', modelId)
             .delete();
     }
     /**
      * sync permissions, remove everything outside of the list
      */
     async sync(modelType, modelId, permissionId) {
-        await ModelPermission.query().where('model_type', modelType).where('model_id', modelId).delete();
-        const many = await this.giveAll(modelType, modelId, permissionId, null, null, true);
-        return many;
+        await this.modelPermissionQuery
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .delete();
+        return await this.giveAll(modelType, modelId, permissionId, null, null, true);
     }
     /**
      * forbid permission on model
@@ -305,8 +353,8 @@ export default class PermissionsService extends BaseService {
      */
     async unforbidAll(modelType, modelId, permissionsSlug, entityType, entityId) {
         // todo replace using reverseModelPermissionQuery() method
-        const q = ModelPermission.query()
-            .leftJoin(Permission.table + ' as p', 'p.id', '=', ModelPermission.table + '.permission_id')
+        const q = this.modelPermissionQuery
+            .leftJoin(this.permissionTable + ' as p', 'p.id', '=', this.modelPermissionTable + '.permission_id')
             .where('model_type', modelType)
             .where('model_id', modelId)
             .whereIn('p.slug', permissionsSlug)
@@ -319,30 +367,22 @@ export default class PermissionsService extends BaseService {
         }
         return q.delete();
     }
-    findBySlug(slug, allowed = true) {
-        return Permission.query().where('slug', slug).where('allowed', allowed).firstOrFail();
+    async findBySlug(slug, allowed = true) {
+        return this.permissionQuery.where('slug', slug).where('allowed', allowed).firstOrFail();
     }
     modelPermissionQueryWithForbiddenCheck(conditions) {
-        const q = this.modelPermissionQuery(conditions);
-        q.whereNotExists((subQuery) => {
-            subQuery
-                .from(Permission.table + ' as p2')
-                .join(ModelPermission.table + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
-                .where('p2.allowed', false)
-                .whereRaw('p2.slug=' + Permission.table + '.slug')
-                .whereRaw('mp2.id=mp.id');
-        });
-        return q;
+        conditions.includeForbiddings = false;
+        return this.modelPermissionQueryBuilder(conditions);
     }
-    modelPermissionQuery(conditions) {
-        const { modelId, modelType, permissionSlugs, directPermissions, includeForbiddens } = conditions;
-        const q = Permission.query().join(ModelPermission.table + ' as mp', 'mp.permission_id', '=', Permission.table + '.id');
+    modelPermissionQueryBuilder(conditions) {
+        const { modelId, modelType, permissionSlugs, directPermissions, includeForbiddings } = conditions;
+        const q = this.permissionQuery.leftJoin(this.modelPermissionTable + ' as mp', 'mp.permission_id', '=', this.permissionTable + '.id');
         if (modelId && modelType) {
             if (directPermissions) {
                 q.where('mp.model_type', modelType).where('mp.model_id', modelId);
             }
             else {
-                q.join(ModelRole.table + ' as mr', (joinQuery) => {
+                q.leftJoin(this.modelRoleTable + ' as mr', (joinQuery) => {
                     joinQuery.onVal('mr.model_type', modelType).onVal('mr.model_id', modelId);
                 }).where((subQuery) => {
                     subQuery
@@ -355,42 +395,46 @@ export default class PermissionsService extends BaseService {
                 });
             }
         }
-        if (!includeForbiddens) {
+        if (!includeForbiddings) {
             q.whereNotExists((subQuery) => {
                 subQuery
-                    .from(Permission.table + ' as p2')
-                    .join(ModelPermission.table + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
+                    .from(this.permissionTable + ' as p2')
+                    .leftJoin(this.modelPermissionTable + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
                     .where('p2.allowed', false)
-                    .whereRaw('p2.slug=' + Permission.table + '.slug')
-                    .whereRaw('mp2.id=mp.id');
+                    .whereRaw('p2.slug=' + this.permissionTable + '.slug')
+                    .select('p2.slug')
+                    .groupBy('p2.slug');
+                if (conditions.entity) {
+                    this.applyTargetRestriction('p2', subQuery, conditions.entity.type, conditions.entity.id);
+                }
             });
         }
         if (permissionSlugs) {
-            q.whereIn(Permission.table + '.slug', permissionSlugs);
+            q.whereIn(this.permissionTable + '.slug', permissionSlugs);
         }
         return q;
     }
     reverseModelPermissionQuery(conditions) {
         const { modelId, modelType, permissionSlugs, directPermissions } = conditions;
-        const q = ModelPermission.query().leftJoin(Permission.table + ' as p', 'p.id', '=', ModelPermission.table + '.permission_id');
+        const q = this.modelPermissionQuery.leftJoin(this.permissionTable + ' as p', 'p.id', '=', this.modelPermissionTable + '.permission_id');
         if (modelId && modelType) {
             if (directPermissions) {
-                q.where(ModelPermission.table + '.model_type', modelType).where(ModelPermission.table + '.model_id', modelId);
+                q.where(this.modelPermissionTable + '.model_type', modelType).where(this.modelPermissionTable + '.model_id', modelId);
             }
             else {
-                q.join(ModelRole.table + ' as mr', (joinQuery) => {
+                q.join(this.modelRoleTable + ' as mr', (joinQuery) => {
                     joinQuery.onVal('mr.model_type', modelType).andOnVal('mr.model_id', modelId);
                 }).where((subQuery) => {
                     subQuery
                         .where((query) => {
                         query
-                            .where(ModelPermission.table + '.model_type', modelType)
-                            .where(ModelPermission.table + '.model_id', modelId);
+                            .where(this.modelPermissionTable + '.model_type', modelType)
+                            .where(this.modelPermissionTable + '.model_id', modelId);
                     })
                         .orWhere((query) => {
                         query
-                            .whereRaw('mr.role_id=' + ModelPermission.table + '.model_id')
-                            .where(ModelPermission.table + '.model_type', 'roles');
+                            .whereRaw('mr.role_id=' + this.modelPermissionTable + '.model_id')
+                            .where(this.modelPermissionTable + '.model_type', 'roles');
                     });
                 });
             }
@@ -400,8 +444,8 @@ export default class PermissionsService extends BaseService {
         }
         return q;
     }
-    findAssignableEntity(permisison, entityClass, entityId, allowed) {
-        const q = Permission.query().whereIn('slug', permisison).where('allowed', allowed);
+    findAssignableEntity(permission, entityClass, entityId, allowed) {
+        const q = this.permissionQuery.whereIn('slug', permission).where('allowed', allowed);
         if (entityClass) {
             q.where('entity_type', entityClass);
             if (entityId) {
@@ -412,27 +456,26 @@ export default class PermissionsService extends BaseService {
             }
         }
         else {
-            q.whereNull('entity_type').whereNull('entity_id');
+            q.where('entity_type', '*').whereNull('entity_id');
         }
         return q;
     }
-    applyTargetRestriction(q, entityType, entityId) {
+    applyTargetRestriction(table, q, entityType, entityId) {
         if (entityType) {
             q.where((query) => {
-                query
-                    .where(Permission.table + '.entity_type', entityType)
-                    .orWhereNull(Permission.table + '.entity_type');
+                query.where(table + '.entity_type', entityType).orWhere(table + '.entity_type', '*');
             });
             if (entityId) {
                 q.where((query) => {
-                    query
-                        .where(Permission.table + '.entity_id', entityId)
-                        .orWhereNull(Permission.table + '.entity_id');
+                    query.where(table + '.entity_id', entityId).orWhereNull(table + '.entity_id');
                 });
             }
+            else {
+                q.whereNull(table + '.entity_id');
+            }
         }
         else {
-            q.whereNull(Permission.table + '.entity_type').whereNull(Permission.table + '.entity_id');
+            q.where(table + '.entity_type', '*').whereNull(table + '.entity_id');
         }
     }
 }

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

@@ -0,0 +1,7 @@
+import { LucidModel, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { ModelPermissionModel, ModelRoleModel, PermissionModel, RoleModel } from '../types.js';
+export declare function getPermissionModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, PermissionModel<T>>;
+export declare function getRoleModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, RoleModel<T>>;
+export declare function getModelPermissionModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, ModelPermissionModel<T>>;
+export declare function getModelRoleModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, ModelRoleModel<T>>;

package/build/src/services/query_helper.js

@@ -0,0 +1,12 @@
+export function getPermissionModelQuery(permissionClassName) {
+    return permissionClassName.query();
+}
+export function getRoleModelQuery(permissionClassName) {
+    return permissionClassName.query();
+}
+export function getModelPermissionModelQuery(permissionClassName) {
+    return permissionClassName.query();
+}
+export function getModelRoleModelQuery(permissionClassName) {
+    return permissionClassName.query();
+}

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

@@ -0,0 +1,8 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+export default class EmptyRoles {
+    private roleClassName;
+    private roleQuery;
+    constructor(roleClassName: typeof BaseModel);
+    delete(role: 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").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+}