@holoyan/adonisjs-permissions 0.6.4 → 0.7.11

package/README.md

@@ -19,6 +19,7 @@
 - [Basic Usage](#basic-usage)
   - [Creating roles and permissions](#creating-roles-and-permissions)
   - [Assigning permissions to the roles (Globally)](#assigning-permissions-to-the-roles-globally)
+  - [Creating permission on a fly](#creating-permission-on-a-fly)
   - [Assigning permissions and roles to the users (models)](#assigning-permissions-and-roles-to-the-users-models)
   - [Multi-model support](#multi-model-support)
   - [Getting all roles for a user](#getting-all-roles-for-a-user)
@@ -30,7 +31,7 @@
   - [Middleware](#middleware)
   - [Removing (revoking) roles and permissions from the model](#removing-revokingdetach-roles-and-permissions-from-the-model)
 - [Digging deeper](#digging-deeper)
-  - [Restricting a permission to a model (On a resource)](#restricting-a-permission-to-a-model-on-a-resource)
+  - [Restricting a permission to a model (On a resource)](#restricting-a-permission-on-a-resource)
   - [Forbidding permissions](#forbidding-permissions)
   - [Forbidding permissions on a resource](#forbidding-permissions-on-a-resource)
   - [Checking for forbidden permissions](#checking-for-forbidden-permissions)
@@ -39,7 +40,8 @@
   - [containsPermission v hasPermission](#containspermission-v-haspermission)
   - [Scopes or Multi-tenancy](#scopes-or-multi-tenancy)
     - [The Scope middleware](#the-scope-middleware) 
-    - [Default Scope](#default-scope-tenant) 
+    - [Default Scope](#default-scope-tenant)
+- [Cheat sheet](#cheat-sheet)
 - [Todo](#todo)
 - [Test](#test)
 - [License](#license)
@@ -115,7 +117,7 @@ export default class Admin extends BaseModel implements AclModelInterface {
 
 @MorphMap('posts')
 export default class Post extends BaseModel implements AclModelInterface {
-  getModelId(): number {
+  getModelId(): number { // use `string` return type if your model has uuid/string primary keys 
     return this.id
   }
 
@@ -162,7 +164,9 @@ await user.allow('edit') // give edit permission
 Currently supported databases: `postgres`, `mysql`, `mssql`
 
 ### UUID support
-No uuid support *yet*, check [todo](#todo) list for more details
+from `v0.7.11` UUID support available, all you need to do change `uuidSupport` value to `true` in `config/permissions.ts` file, then run the migration and don't forget to change return type for the `getModelId()` method 
+
+check [todo](#todo) list for more details
 
 ## Basic Usage
 
@@ -172,10 +176,13 @@ On this section, we will explore basic role permission methods.
 
 Let's manually create `create,update,read,delete` permissions, as well as `admin,manager` roles
 
+> Look also [Creating permissions on a fly](#creating-permissions-on-a-fly) section
+
 ```typescript
 
 import { Permission } from '@holoyan/adonisjs-permissions'
 import { Role } from '@holoyan/adonisjs-permissions'
+import {Acl} from "@holoyan/adonisjs-permissions";
 
 
 // create permissions
@@ -188,12 +195,14 @@ const update = await Permission.create({
   slug:'update',
 })
 
-const read = await Permission.create({
-  slug:'read',
+// or create using Acl (recomended way)
+const read = await Acl.permission().create({
+  slug: 'read',
 })
 
-const delete = await Permission.create({
-  slug:'delete',
+
+const delete = await Acl.permission().create({
+  slug: 'delete',
 })
 
 // create roles
@@ -202,8 +211,9 @@ const admin = await Role.create({
   title:'Cool title for Admin', // optional
 })
 
-const manager = await Role.create({
-  slug:'manager',
+// or create using Acl (recomended way)
+const manager = await Acl.role().create({
+  slug: 'manager',
 })
 
 ```
@@ -228,13 +238,15 @@ await Acl.role(admin).giveAll(['read', 'delete'])
 
 ```
 
+### Creating permissions on a fly
+
 In case you are assigning a permission that is not already available, `Acl` will create new permission behind the scenes and assign them.
 
 ```typescript
 
-// uploadFile permissions not available
+// uploadFile permission not available
 await Acl.role(admin).allow('uploadFile')
-// uploadFile permission created and assigned
+// 'uploadFile' permission created and assigned
 
 ```
 
@@ -249,12 +261,12 @@ import User from "#models/user";
 
 const user1 = await User.query().where(condition1).first()
 // give manager role to the user1
-await Acl.model(user1).assignRole(manager)
+await Acl.model(user1).assignRole('manager')
 // or just use assign() method, they are alias
-// await Acl.model(user1).assign(manager)
+// await Acl.model(user1).assign('manager')
 
 const user2 = await User.query().where(condition2).first()
-await Acl.model(user2).assignRole(admin)
+await Acl.model(user2).assign(admin)
 
 ```
 Or we can give permissions directly to users without having any role
@@ -265,7 +277,7 @@ import {Acl} from "@holoyan/adonisjs-permissions";
 
 // create and assign a new permission
 Acl.model(user1).assignDirectPermission('upload-file-slug')
-// or use allow method
+// or use allow() method
 Acl.model(user1).allow('permissionSlug')
 ```
 
@@ -275,9 +287,9 @@ We are not limited to using only the User model. If you have a multi-auth system
 
 
 ```typescript
-await Acl.model(user).assignRole(manager)
+await Acl.model(user).assignRole('manager')
 
-await Acl.model(admin).assignRole(admin)
+await Acl.model(admin).assignRole('admin')
 
 ```
 
@@ -306,7 +318,7 @@ const roles = await Acl.role(role).permissions()
 const roles = await Acl.model(user).permissions()
 ```
 
-### Getting users (models) from the permission
+### Getting models from the permission
 
 ```typescript
 
@@ -453,7 +465,7 @@ export default class AclMiddleware {
 
 ### Removing (revoking/detach) roles and permissions from the model
 
-To remove(detach) role from the user we can use `revoke` method
+To revoke(detach) role from the user we can use `revoke` method
 
 ```typescript
 
@@ -465,7 +477,7 @@ await Acl.model(user).flushRoles()
 
 ```
 
-Removing permissions from the user
+Revoking permissions from the user
 
 ```typescript
 await Acl.model(user).revokePermission('update')
@@ -503,7 +515,7 @@ await Acl.role(role).flushPermissions()
 
 ### Deleting roles and permissions (Important!)
 
-> Important! use Acl to delete roles and permissions, under the hood Acl does some checking
+> Recommended! use Acl to delete roles and permissions instead of directly making queries on the Role,Permission model, under the hood Acl does some checking
 
 ```typescript
 
@@ -519,9 +531,9 @@ To see in dept usage of this methods check [next section](#digging-deeper)
 
 In the [previous](#basic-usage) section, we looked at basic examples and usage. Most of the time, basic usage will probably be enough for your project. However, there is much more we can do with `Acl`.
 
-### Restricting a permission to a model (On a resource)
+### Restricting a permission on a resource
 
-Sometimes you might want to restrict a permission to a specific model type. Simply pass the model as a second argument:
+Sometimes you might want to restrict a permission on a specific model(resource). Simply pass the model as a second argument:
 
 ```typescript
 import Product from "#models/product";
@@ -635,15 +647,15 @@ Good news!, we can do that
 await Acl.role(manager).giveAll(['create','update','read','delete'])
 
 // assigning to the users
-await Acl.model(user1).assign(manager)
+await Acl.model(user1).assign('manager')
 
-await Acl.model(user3).assign(manager)
+await Acl.model(user3).assign('manager')
 await Acl.model(user3).forbid('delete')
 
-await Acl.model(user1).hasRole(manager) // true
+await Acl.model(user1).hasRole('manager') // true
 await Acl.model(user1).can('delete') // true
 
-await Acl.model(user3).hasRole(manager) // true
+await Acl.model(user3).hasRole('manager') // true
 await Acl.model(user3).can('delete') // false
 
 await Acl.model(user3).contains('delete') // true
@@ -668,7 +680,7 @@ In [previous](#forbidding-permissions) section we saw how to forbid certain perm
 
 ```typescript
 
-await Acl.model(user3).assignRole(manager)
+await Acl.model(user3).assignRole('manager')
 await Acl.model(user3).forbid('delete')
 
 await Acl.model(user3).forbidden('delete') // true
@@ -688,7 +700,7 @@ await Acl.model(user).forbidden('edit', post7) // false becouse 'edit' action fo
 
 ```typescript
 
-await Acl.model(user3).assignRole(manager)
+await Acl.model(user3).assignRole('manager')
 await Acl.model(user3).forbid('delete')
 
 await Acl.model(user3).forbidden('delete') // true
@@ -703,7 +715,7 @@ await Acl.model(user3).can('delete') // true
 Same behaviour applies with roles
 
 ```typescript
-await Acl.role(role).assignRole(manager)
+await Acl.role(role).assignRole('manager')
 await Acl.role(role).forbid('delete')
 
 await Acl.role(role).forbidden('delete') // true
@@ -922,10 +934,15 @@ export default class PostController {
 > Default Scope value is equal to 0 (zero)
 
 
+## Cheat sheet
+
+Coming soon
+
+
 ## TODO
 
 - [X] Scopes (Multitenancy)
-- [ ] UUID support
+- [X] UUID support
 - [ ] Events
 - [ ] More test coverage
 - [ ] Caching

package/build/src/mixins/has_permissions.d.ts

@@ -1,35 +1,34 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
-import Permission from '../models/permission.js';
-import { AclModel, RoleInterface } from '../types.js';
+import { AclModel } from '../types.js';
 export declare function hasPermissions(): <Model extends NormalizeConstructor<import("@adonisjs/lucid/types/model").LucidModel>>(superclass: Model) => {
     new (...args: any[]): {
-        getModelId(): number;
+        getModelId(): string;
         roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
-        hasRole(role: string | RoleInterface): Promise<boolean>;
-        hasAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
-        hasAnyRole(...roles: (string | RoleInterface)[]): Promise<boolean>;
-        assignRole(role: string | RoleInterface): Promise<boolean>;
-        revokeRole(role: string | number | RoleInterface): Promise<boolean>;
-        revokeAllRoles(...roles: (string | number | RoleInterface)[]): Promise<boolean>;
+        hasRole(role: string): Promise<boolean>;
+        hasAllRoles(...roles: string[]): Promise<boolean>;
+        hasAnyRole(...roles: string[]): Promise<boolean>;
+        assignRole(role: string): Promise<boolean>;
+        revokeRole(role: string): Promise<boolean>;
+        revokeAllRoles(...roles: string[]): Promise<boolean>;
         permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
         globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
         onResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
         directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
         directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-        containsPermission(permission: string | Permission): Promise<boolean>;
-        containsAllPermissions(permissions: (string | Permission)[]): Promise<boolean>;
-        containsAnyPermission(permissions: (string | Permission)[]): Promise<boolean>;
-        containsDirectPermission(permission: string | Permission): Promise<boolean>;
-        containsAllPermissionsDirectly(permissions: (string | Permission)[]): Promise<boolean>;
-        containsAnyPermissionDirectly(permissions: (string | Permission)[]): Promise<boolean>;
-        hasPermission(permission: string | Permission, target?: AclModel | Function): Promise<boolean>;
-        hasAllPermissions(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-        hasAnyPermission(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-        hasAnyDirectPermission(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-        hasDirectPermission(permission: string | Permission, target?: AclModel | Function): Promise<boolean>;
-        hasAllPermissionsDirect(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-        canAll(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-        canAny(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        containsPermission(permission: string): Promise<boolean>;
+        containsAllPermissions(permissions: string[]): Promise<boolean>;
+        containsAnyPermission(permissions: string[]): Promise<boolean>;
+        containsDirectPermission(permission: string): Promise<boolean>;
+        containsAllPermissionsDirectly(permissions: string[]): Promise<boolean>;
+        containsAnyPermissionDirectly(permissions: string[]): Promise<boolean>;
+        hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+        hasAllPermissions(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        hasAnyPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        hasAnyDirectPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        hasDirectPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+        hasAllPermissionsDirect(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        canAny(permissions: string[], target?: AclModel | Function): Promise<boolean>;
         assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
         allow(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
         revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;

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

@@ -1,12 +1,12 @@
 import { DateTime } from 'luxon';
 import { BaseModel } from '@adonisjs/lucid/orm';
-export default class ModelPermission extends BaseModel {
+import { ModelIdType, ModelPermissionInterface } from '../types.js';
+export default class ModelPermission extends BaseModel implements ModelPermissionInterface {
     static get table(): string;
     id: number;
-    permissionId: number;
+    permissionId: ModelIdType;
     modelType: string;
-    modelId: number;
+    modelId: ModelIdType;
     createdAt: DateTime;
     updatedAt: DateTime;
-    static forModel: import("@adonisjs/lucid/types/model").QueryScope<import("@adonisjs/lucid/types/model").LucidModel, (query: import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidRow>, modelType: string, modelId: number | null) => void>;
 }

package/build/src/models/model_permission.js

@@ -4,16 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, scope } from '@adonisjs/lucid/orm';
+import { BaseModel, column } from '@adonisjs/lucid/orm';
 import config from '@adonisjs/core/services/config';
 export default class ModelPermission extends BaseModel {
     static get table() {
         return config.get('permissions.permissionsConfig.tables.modelPermissions');
     }
-    static forModel = scope((query, modelType, modelId) => {
-        query.where('model_type', modelType);
-        modelId === null ? query.whereNull('model_id') : query.where('model_id', modelId);
-    });
 }
 __decorate([
     column({ isPrimary: true })

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

@@ -1,11 +1,12 @@
 import { DateTime } from 'luxon';
 import { BaseModel } from '@adonisjs/lucid/orm';
-export default class ModelRole extends BaseModel {
+import { ModelIdType, ModelRoleInterface } from '../types.js';
+export default class ModelRole extends BaseModel implements ModelRoleInterface {
     static get table(): string;
     id: number;
-    roleId: number;
+    roleId: ModelIdType;
     modelType: string;
-    modelId: number | null;
+    modelId: ModelIdType;
     createdAt: DateTime;
     updatedAt: DateTime;
 }

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

@@ -1,14 +1,16 @@
 import { DateTime } from 'luxon';
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { PermissionInterface } from '../types.js';
+import { ModelIdType, PermissionInterface } from '../types.js';
 export default class Permission extends BaseModel implements PermissionInterface {
     static get table(): string;
-    getModelId(): number;
-    id: number;
+    static get selfAssignPrimaryKey(): boolean;
+    static assignUuid(permission: Permission): void;
+    getModelId(): ModelIdType;
+    id: string;
     slug: string;
     title: string | null;
     entityType: string;
-    entityId: number | null;
+    entityId: string | null;
     allowed: boolean;
     scope: number;
     createdAt: DateTime;

package/build/src/models/permission.js

@@ -4,12 +4,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { v4 as uuidv4 } from 'uuid';
+import { BaseModel, beforeCreate, column } from '@adonisjs/lucid/orm';
 import config from '@adonisjs/core/services/config';
 export default class Permission extends BaseModel {
     static get table() {
         return config.get('permissions.permissionsConfig.tables.permissions');
     }
+    static get selfAssignPrimaryKey() {
+        return config.get('permissions.permissionsConfig.uuidSupport');
+    }
+    static assignUuid(permission) {
+        permission.id = uuidv4();
+    }
     getModelId() {
         return this.id;
     }
@@ -41,3 +48,6 @@ __decorate([
 __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true })
 ], Permission.prototype, "updatedAt", void 0);
+__decorate([
+    beforeCreate()
+], Permission, "assignUuid", null);

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

@@ -1,14 +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 {
+import { ModelIdType, RoleInterface } from '../types.js';
+export default class Role extends BaseModel implements RoleInterface {
     static get table(): string;
-    getModelId(): number;
-    id: number;
+    static get selfAssignPrimaryKey(): boolean;
+    static assignUuid(role: Role): void;
+    getModelId(): ModelIdType;
+    id: string;
     slug: string;
     title: string | null;
     entityType: string;
-    entityId: number | null;
+    entityId: string | null;
     scope: number;
     allowed: boolean;
     createdAt: DateTime;

package/build/src/models/role.js

@@ -4,12 +4,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { BaseModel, beforeCreate, column } from '@adonisjs/lucid/orm';
 import config from '@adonisjs/core/services/config';
+import { v4 as uuidv4 } from 'uuid';
 export default class Role extends BaseModel {
     static get table() {
         return config.get('permissions.permissionsConfig.tables.roles');
     }
+    static get selfAssignPrimaryKey() {
+        return config.get('permissions.permissionsConfig.uuidSupport');
+    }
+    static assignUuid(role) {
+        role.id = uuidv4();
+    }
     getModelId() {
         return this.id;
     }
@@ -41,3 +48,6 @@ __decorate([
 __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true })
 ], Role.prototype, "updatedAt", void 0);
+__decorate([
+    beforeCreate()
+], Role, "assignUuid", null);

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

@@ -16,5 +16,5 @@ export declare function destructTarget(map: MorphInterface, target?: AclModel |
     targetId: null;
 } | {
     targetClass: string;
-    targetId: number | null;
+    targetId: import("../types.js").ModelIdType | null;
 }>;

package/build/src/services/helper.js

@@ -1,17 +1,18 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
 export function formatList(models) {
     let slugs = [];
     let ids = [];
     for (let model of models) {
-        if (typeof model === 'string') {
+        if (model instanceof BaseModel) {
+            // @ts-ignore
+            slugs.push(model.slug);
+        }
+        else if (typeof model === 'string' && Number.isNaN(+model)) {
             slugs.push(model);
         }
         else if (typeof model === 'number') {
             ids.push(model);
         }
-        else {
-            // @ts-ignore
-            ids.push(model.id);
-        }
     }
     return { slugs, ids };
 }

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

@@ -1,4 +1,4 @@
-import { AclModel, MorphInterface, PermissionInterface, RoleInterface, ScopeInterface } from '../types.js';
+import { AclModel, MorphInterface, ScopeInterface } from '../types.js';
 import PermissionsService from './permissions/permissions_service.js';
 import RolesService from './roles/roles_service.js';
 export declare class ModelHasRolePermissions {
@@ -11,14 +11,14 @@ export declare class ModelHasRolePermissions {
     on(scope: number): this;
     getScope(): number;
     roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
-    hasRole(role: string | RoleInterface): Promise<boolean>;
-    hasAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
-    hasAnyRole(...roles: (string | RoleInterface)[]): Promise<boolean>;
-    assignRole(role: string | RoleInterface): Promise<boolean>;
-    assign(role: string | RoleInterface): Promise<boolean>;
-    assignAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
-    revokeRole(role: string | number | RoleInterface): Promise<boolean>;
-    revokeAllRoles(...roles: (string | number | RoleInterface)[]): Promise<boolean>;
+    hasRole(role: string): Promise<boolean>;
+    hasAllRoles(...roles: string[]): Promise<boolean>;
+    hasAnyRole(...roles: string[]): Promise<boolean>;
+    assignRole(role: string): Promise<boolean>;
+    assign(role: string): Promise<boolean>;
+    assignAllRoles(...roles: string[]): Promise<boolean>;
+    revokeRole(role: string): Promise<boolean>;
+    revokeAllRoles(...roles: string[]): Promise<boolean>;
     flushRoles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
     permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
@@ -27,25 +27,26 @@ export declare class ModelHasRolePermissions {
     rolePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    containsPermission(permission: string | PermissionInterface): Promise<boolean>;
-    contains(permission: string | PermissionInterface): Promise<boolean>;
-    containsAllPermissions(permissions: (string | PermissionInterface)[]): Promise<boolean>;
-    containsAnyPermission(permissions: (string | PermissionInterface)[]): Promise<boolean>;
-    containsDirectPermission(permission: string | PermissionInterface): Promise<boolean>;
-    containsAllPermissionsDirectly(permissions: (string | PermissionInterface)[]): Promise<boolean>;
-    containsAnyPermissionDirectly(permissions: (string | PermissionInterface)[]): Promise<boolean>;
-    hasPermission(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissions(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyPermission(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyDirectPermission(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
-    hasDirectPermission(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissionsDirect(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
-    can(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
-    canAll(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
-    canAny(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    containsPermission(permission: string): Promise<boolean>;
+    contains(permission: string): Promise<boolean>;
+    containsAllPermissions(permissions: string[]): Promise<boolean>;
+    containsAnyPermission(permissions: string[]): Promise<boolean>;
+    containsDirectPermission(permission: string): Promise<boolean>;
+    containsAllPermissionsDirectly(permissions: string[]): Promise<boolean>;
+    containsAnyPermissionDirectly(permissions: string[]): Promise<boolean>;
+    hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissions(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyDirectPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    hasDirectPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissionsDirect(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    can(permission: string, target?: AclModel | Function): Promise<boolean>;
+    canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    canAny(permissions: string[], target?: AclModel | Function): Promise<boolean>;
     assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     assignDirectAllPermissions(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     allow(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    allowAll(permission: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
     revoke(permission: string, target?: AclModel | Function): Promise<any[]>;
     revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;

package/build/src/services/model_has_role_permissions.js

@@ -45,8 +45,8 @@ export class ModelHasRolePermissions {
         return this.revokeAllRoles(role);
     }
     revokeAllRoles(...roles) {
-        const { slugs, ids } = formatList(roles);
-        return this.roleService.revokeAll([...slugs, ...ids], this.model);
+        const { slugs } = formatList(roles);
+        return this.roleService.revokeAll(slugs, this.model);
     }
     flushRoles() {
         return this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
@@ -140,7 +140,10 @@ export class ModelHasRolePermissions {
         return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
     }
     allow(permission, target) {
-        return this.assignDirectPermission(permission, target);
+        return this.allowAll([permission], target);
+    }
+    allowAll(permission, target) {
+        return this.assignDirectAllPermissions(permission, target);
     }
     async revokePermission(permission, target) {
         return this.revokeAllPermissions([permission], target);

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

@@ -1,6 +1,6 @@
 import BaseService from './base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { MorphInterface } from '../types.js';
+import { ModelIdType, MorphInterface } from '../types.js';
 export default class ModelService extends BaseService {
     private modelPermissionClassName;
     private modelRoleClassName;
@@ -12,6 +12,6 @@ export default class ModelService extends BaseService {
     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<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
-    allByPermissionFor(modelType: string, permissionId: number): Promise<any>;
+    allByPermission(permissionId: ModelIdType): 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: ModelIdType): Promise<any>;
 }

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

@@ -1,5 +1,5 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ScopeInterface } from '../../types.js';
+import { PermissionInterface, PermissionModel, ScopeInterface } from '../../types.js';
 export default class EmptyPermission {
     private permissionClassName;
     private scope;
@@ -8,5 +8,6 @@ export default class EmptyPermission {
     on(scope: number): this;
     getScope(): number;
     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>>;
+    create(values: Partial<PermissionInterface>): Promise<PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
 }