@holoyan/adonisjs-permissions 1.1.0 → 1.3.0

package/README.md

@@ -12,6 +12,11 @@ Checkout other AdonisJS packages
 - It's simple, just star this repository, that is enough to keep me motivated to maintain this package.
 
 
+## Release Notes
+
+Version: >= v1.3.0
+* Added [query helpers](#permissionqueryhelpers-mixin) mixin. To make it easier to query users(models) based on their roles and permissions
+
 ## Table of Contents
 
 <details><summary>Click to expand</summary><p>
@@ -20,6 +25,8 @@ Checkout other AdonisJS packages
 - [Installation](#installation)
 - [Configuration](#configuration)
 - [Mixins](#mixins)
+  - [hasPermissions](#haspermissions-mixin)
+  - [permissionQueryHelpers](#permissionqueryhelpers-mixin)
 - [Support](#support)
   - [Database support](#database-support)
   - [UUID support](#uuid-support)
@@ -49,7 +56,7 @@ Checkout other AdonisJS packages
     - [The Scope middleware](#the-scope-middleware) 
     - [Default Scope](#default-scope-tenant)
   - [Transactions](#transactions)
-  - [Events] (#events)
+  - [Events](#events)
 - [Cheat sheet](#cheat-sheet)
 - [Todo](#todo)
 - [Test](#test)
@@ -105,7 +112,7 @@ Example.
 ```typescript
 
 import { BaseModel, column } from '@adonisjs/lucid/orm'
-import { MorphMap } from '@holoyan/adonisjs-permissions'
+import { MorphMap } from '@holoyan/morph-map-js'  // (NOTE upper case `MorphMap`)
 import { AclModelInterface } from '@holoyan/adonisjs-permissions/types'
 
 @MorphMap('users')
@@ -136,19 +143,16 @@ export default class Post extends BaseModel implements AclModelInterface {
 
 ```
 
-## Release Notes
-
-Version: >= v1.1.0
-* Added support for [Events](#events)
-
 ## Mixins
 
+### hasPermissions mixin
+
 If you want to be able to call `Acl` methods on a `User` model then consider using `hasPermissions` mixin
 
 ```typescript
 
 import { BaseModel, column } from '@adonisjs/lucid/orm'
-import { MorphMap } from '@holoyan/adonisjs-permissions'
+import { MorphMap } from '@holoyan/morph-map-js'  // (NOTE upper case `MorphMap`)
 import { AclModelInterface } from '@holoyan/adonisjs-permissions/types'
 
 // import mixin
@@ -172,6 +176,61 @@ await user.allow('edit') // give edit permission
 
 ```
 
+
+### permissionQueryHelpers mixin
+
+Sometimes you might want to get all users who have a specific permission, for that you can use `permissionQueryHelpers` mixin
+
+```typescript
+
+import { permissionQueryHelpers } from '@holoyan/adonisjs-permissions'
+
+
+@MorphMap('users')
+export default class User extends compose(BaseModel, permissionQueryHelpers()) implements AclModelInterface {
+  getModelId(): number {
+    return this.id
+  }
+  // other code goes here
+
+  // name your scopes whatever you want, make sure to call query helper methods inside the scope
+  static whereRoles = scope((query, ...roles: string[]) => {
+    // all users who have roles
+    new User()._whereRoles(query, User, ...roles)
+  })
+
+  static whereDirectPermissions = scope(
+    (query, permissions: string[], target?: AclModel | Function) => {
+      // all users who have direct assigned permissions
+      new User()._whereDirectPermissions(query, User, permissions, target)
+    }
+  )
+
+  static whereRolePermissions = scope(
+    (query, permissions: string[], target?: AclModel | Function) => {
+      // all users who have permissions assigned through the role
+      new User()._whereRolePermissions(query, User, permissions, target)
+    }
+  )
+
+  static wherePermissions = scope((query, permissions: string[], target?: AclModel | Function) => {
+    // all users who have permissions assigned directly or through the role
+    new User()._wherePermissions(query, User, permissions, target)
+  })
+}
+
+```
+
+And to get all users who have `edit` permission, you can do that like this
+
+```typescript
+
+const users = await User.query().withScopes((scopes) => {
+  scopes.wherePermissions(['edit'])
+})
+
+```
+
 ## Support
 
 ### Database Support
@@ -1011,6 +1070,42 @@ await Acl.model(myUser).allow('create')
 
 ```
 
+
+You can also disable events per query by calling withoutEvents() method
+
+```typescript
+
+emitter.on(RoleCreatedEvent, () => {
+  console.log('Role created') // this will not be called
+})
+
+//
+await Acl.role().withoutEvents().create({ // this one will not trigger RoleCreatedEvent
+  slug: 'admin',
+})
+
+await Acl.role().create({ // this will trigger
+  slug: 'admin',
+})
+
+```
+
+If you want to completely disable events, you can do that by calling `withoutEvents()` method on the `Acl` class
+
+```typescript
+
+Acl.withoutEvents()
+
+// any method called on the Acl will not trigger any events
+emitter.on(RoleCreatedEvent, () => {
+  console.log('Role created') // this will not be called
+})
+
+await Acl.role().create({ // this will not trigger because globaly withoutEvents() is set
+  slug: 'admin',
+})
+```
+
 List of events you can listen to:
 
 ```
@@ -1237,6 +1332,7 @@ await Acl.permission(myPermission).detachFromRole(role_slug)
 - [X] Scopes (Multitenancy)
 - [X] UUID support
 - [X] Events
+- [X] Query helpers
 - [ ] More test coverage
 - [ ] Caching
 - [ ] Integration with AdonisJs Bouncer
@@ -1251,7 +1347,7 @@ await Acl.permission(myPermission).detachFromRole(role_slug)
 
 | AdonisJS Lucid version | Package version |
 |------------------------|-----------------|
-| v20.x                  | 0.9.x           |
+| v20.x                  | 0.10.x          |
 | v21.x                  | 1.x             |
 
 

package/build/index.d.ts

@@ -10,6 +10,5 @@ export { configure } from './configure.js';
 export { stubsRoot } from './stubs/main.js';
 export { AclManager, Acl } from './src/acl.js';
 export { MorphMap, getClassPath } from './src/decorators.js';
-export * as morphMapModel from './src/morph_map.js';
-export { hasPermissions } from './src/mixins/has_permissions.js';
+export { hasPermissions, permissionQueryHelpers } from './src/mixins/has_permissions.js';
 export { Scope } from './src/scope.js';

package/build/index.js

@@ -18,6 +18,5 @@ export { configure } from './configure.js';
 export { stubsRoot } from './stubs/main.js';
 export { AclManager, Acl } from './src/acl.js';
 export { MorphMap, getClassPath } from './src/decorators.js';
-export * as morphMapModel from './src/morph_map.js';
-export { hasPermissions } from './src/mixins/has_permissions.js';
+export { hasPermissions, permissionQueryHelpers } from './src/mixins/has_permissions.js';
 export { Scope } from './src/scope.js';

package/build/providers/role_permission_provider.d.ts

@@ -1,9 +1,9 @@
 import { ApplicationService } from '@adonisjs/core/types';
 import ModelManager from '../src/model_manager.js';
-import MorphMap from '../src/morph_map.js';
+import { MorphMapManager } from '@holoyan/morph-map-js';
 declare module '@adonisjs/core/types' {
     interface ContainerBindings {
-        morphMap: MorphMap;
+        morphMap: MorphMapManager;
         modelManager: ModelManager;
     }
 }

package/build/providers/role_permission_provider.js

@@ -4,8 +4,8 @@ import ModelPermission from '../src/models/model_permission.js';
 import ModelRole from '../src/models/model_role.js';
 import ModelManager from '../src/model_manager.js';
 import { AclManager } from '../src/acl.js';
-import MorphMap from '../src/morph_map.js';
 import { Scope } from '../src/scope.js';
+import { morphMap } from '@holoyan/morph-map-js';
 export default class RolePermissionProvider {
     app;
     constructor(app) {
@@ -13,7 +13,7 @@ export default class RolePermissionProvider {
     }
     register() {
         this.app.container.singleton('morphMap', async () => {
-            return new MorphMap();
+            return morphMap;
         });
         this.app.container.singleton('modelManager', async () => {
             return new ModelManager();
@@ -39,8 +39,8 @@ export default class RolePermissionProvider {
         AclManager.setModelManager(modelManager);
         AclManager.setEmitter(emitter);
         const map = await this.app.container.make('morphMap');
-        map.set('permissions', Permission);
-        map.set('roles', Role);
+        // map.set('permissions', Permission)
+        // map.set('roles', Role)
         AclManager.setMorphMap(map);
     }
 }

package/build/src/decorators.js

@@ -1,19 +1,11 @@
-import app from '@adonisjs/core/services/app';
+import { morphMap, getClassPath as baseGetClassPath } from '@holoyan/morph-map-js';
+// keep for backward compatibility
 export function MorphMap(param) {
     return function (target) {
-        const service = async function () {
-            var result = await app.container.make('morphMap');
-            result.set(param, target);
-            return param;
-        };
-        target.prototype.__morphMapName = service();
+        morphMap.set(param, target);
         target.prototype.__morphMapName = param;
     };
 }
 export function getClassPath(clazz) {
-    const morphMapName = clazz.prototype.__morphMapName;
-    if (!morphMapName) {
-        throw new Error('morph map name not specified');
-    }
-    return morphMapName;
+    return baseGetClassPath(clazz);
 }

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

@@ -1,13 +1,18 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
 import { BaseModel } from '@adonisjs/lucid/orm';
 import { AclModel, ModelIdType } from '../types.js';
+import type { ManyToMany, HasMany } from '@adonisjs/lucid/types/relations';
+import Role from '../models/role.js';
+import { LucidModel, LucidRow, ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+import { ModelRole, Permission } from '../../index.js';
+import ModelPermission from '../models/model_permission.js';
 export declare function hasPermissions(): <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => {
     new (...args: any[]): {
         getModelId(): ModelIdType;
         /**
          * returns list of roles assigned to the model
          */
-        roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof import("../models/role.js").default, import("../models/role.js").default>;
+        roles(): ModelQueryBuilderContract<typeof Role, Role>;
         /**
          * Check if model has role
          * @param role
@@ -142,13 +147,13 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
          * @param permission
          * @param target
          */
-        assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+        assignDirectPermission(permission: string, target?: AclModel | Function): Promise<ModelPermission[]>;
         /**
          * Allow permission for model
          * @param permission
          * @param target
          */
-        allow(permission: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+        allow(permission: string, target?: AclModel | Function): Promise<ModelPermission[]>;
         /**
          * Revoke permission from model
          * @param permission
@@ -185,7 +190,7 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
          * @param permissions
          * @param target
          */
-        syncPermissions(permissions: string[], target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+        syncPermissions(permissions: string[], target?: AclModel | Function): Promise<ModelPermission[]>;
         /**
          * Forbid permission for model
          * @param permission
@@ -214,7 +219,7 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
         $extras: import("@adonisjs/lucid/types/model").ModelObject;
         $original: import("@adonisjs/lucid/types/model").ModelObject;
         $preloaded: {
-            [relation: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+            [relation: string]: LucidRow | LucidRow[];
         };
         $columns: undefined;
         $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
@@ -231,14 +236,14 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
         useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
         useConnection(connection: string): /*elided*/ any;
         $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
-        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): ModelQueryBuilderContract<LucidModel>;
         $setAttribute(key: string, value: any): void;
         $getAttribute(key: string): any;
         $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
         $hasRelated(key: string): boolean;
-        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
-        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
-        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | undefined | null;
+        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | null): void;
+        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | null): void;
+        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | undefined | null;
         $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
         $hydrateOriginals(): void;
         fill(value: Partial<{}>, allowExtraProperties?: boolean): /*elided*/ any;
@@ -246,28 +251,30 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
         isDirty(fields?: undefined[] | undefined): boolean;
         enableForceUpdate(): /*elided*/ any;
         save(): Promise</*elided*/ any>;
+        saveQuietly(): Promise</*elided*/ any>;
         lockForUpdate<T>(callback: (user: /*elided*/ any) => T | Promise<T>): Promise<T>;
         delete(): Promise<void>;
+        deleteQuietly(): Promise<void>;
         refresh(): Promise</*elided*/ any>;
         load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
         loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
         preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
-        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
-        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
         serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
         serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
         serializeRelations(fields: undefined, raw: true): {
-            [key: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
+            [key: string]: LucidRow | LucidRow[];
         };
         serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
         serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
         serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
         toObject(): import("@adonisjs/lucid/types/model").ModelObject;
         toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
-        related<Name_2 extends undefined>(relation: Name_2): /*elided*/ any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? /*elided*/ any[Name_2]["client"] : never;
+        related<Name_2 extends undefined>(relation: Name_2): /*elided*/ any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? /*elided*/ any[Name_2]["client"] : never;
     };
-    find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
-    all: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    find: <T extends LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    all: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
     namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
     connection?: string | undefined;
     readonly booted: boolean;
@@ -288,57 +295,204 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
         serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
         serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
     };
-    $createFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
-    $createMultipleFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
+    $createFromAdapterResult: <T extends LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
+    $createMultipleFromAdapterResult: <T extends LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
     $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
     $hasColumn: (name: string) => boolean;
     $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
     $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
     $hasComputed: (name: string) => boolean;
     $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
-    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
     $hasRelation: (name: string) => boolean;
     $getRelation: {
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): InstanceType<Model_1>[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? InstanceType<Model_1>[Name_2]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): InstanceType<Model_1>[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? InstanceType<Model_1>[Name_2]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
     };
-    $defineProperty: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
+    $defineProperty: <Model_1 extends LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
     boot: () => void;
     before: {
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event>): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>], "paginate">): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
+        <Model_1 extends LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<ModelQueryBuilderContract<Model_1>, Event>): void;
+        <Model_1 extends LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[ModelQueryBuilderContract<Model_1>, ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
     };
     after: {
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
+        <Model_1 extends LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
+        <Model_1 extends LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
+        <Model_1 extends LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
     };
-    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
-    createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
-    findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    create: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createQuietly: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createMany: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    createManyQuietly: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    findOrFail: <T extends LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
     findBy: {
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
     };
     findByOrFail: {
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
     };
     findManyBy: {
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
-        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
     };
-    first: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
-    firstOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
-    findMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
-    firstOrNew: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
-    firstOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
-    updateOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
-    fetchOrNewUpMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
-    fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
-    updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
-    query: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1, Result>;
+    first: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    firstOrFail: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findMany: <T extends LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    firstOrNew: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    firstOrCreate: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    updateOrCreate: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    fetchOrNewUpMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    fetchOrCreateMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    updateOrCreateMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    query: <Model_1 extends LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => ModelQueryBuilderContract<Model_1, Result>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    truncate: (cascade?: boolean) => Promise<void>;
+} & Model;
+export declare function permissionQueryHelpers(): <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => {
+    new (...args: any[]): {
+        _roles: ManyToMany<typeof Role>;
+        _whereRoles<TargetClass extends Model>(query: ModelQueryBuilderContract<LucidModel, LucidRow>, targetClass: TargetClass, ...roles: string[]): ModelQueryBuilderContract<LucidModel, LucidRow>;
+        _permissions: ManyToMany<typeof Permission>;
+        _whereDirectPermissions<TargetClass extends Model>(query: ModelQueryBuilderContract<LucidModel, LucidRow>, targetClass: TargetClass, permissions: string[], target?: AclModel | Function): ModelQueryBuilderContract<LucidModel, LucidRow>;
+        _model_roles: HasMany<typeof ModelRole>;
+        _whereRolePermissions<TargetClass extends Model>(query: ModelQueryBuilderContract<LucidModel, LucidRow>, targetClass: TargetClass, permissions: string[], target?: AclModel | Function): ModelQueryBuilderContract<LucidModel, LucidRow>;
+        _wherePermissions<TargetClass extends Model>(query: ModelQueryBuilderContract<LucidModel, LucidRow>, targetClass: TargetClass, permissions: string[], target?: AclModel | Function): void;
+        $attributes: import("@adonisjs/lucid/types/model").ModelObject;
+        $extras: import("@adonisjs/lucid/types/model").ModelObject;
+        $original: import("@adonisjs/lucid/types/model").ModelObject;
+        $preloaded: {
+            [relation: string]: LucidRow | LucidRow[];
+        };
+        $columns: undefined;
+        $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
+        $primaryKeyValue?: number | string;
+        $isPersisted: boolean;
+        $isNew: boolean;
+        $isLocal: boolean;
+        $dirty: import("@adonisjs/lucid/types/model").ModelObject;
+        $isDirty: boolean;
+        $isDeleted: boolean;
+        $options?: import("@adonisjs/lucid/types/model").ModelOptions;
+        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract;
+        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): void;
+        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
+        useConnection(connection: string): /*elided*/ any;
+        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): ModelQueryBuilderContract<LucidModel>;
+        $setAttribute(key: string, value: any): void;
+        $getAttribute(key: string): any;
+        $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
+        $hasRelated(key: string): boolean;
+        $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | null): void;
+        $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | null): void;
+        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<LucidRow> | undefined | null;
+        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
+        $hydrateOriginals(): void;
+        fill(value: Partial<{}>, allowExtraProperties?: boolean): /*elided*/ any;
+        merge(value: Partial<{}>, allowExtraProperties?: boolean): /*elided*/ any;
+        isDirty(fields?: undefined[] | undefined): boolean;
+        enableForceUpdate(): /*elided*/ any;
+        save(): Promise</*elided*/ any>;
+        saveQuietly(): Promise</*elided*/ any>;
+        lockForUpdate<T>(callback: (user: /*elided*/ any) => T | Promise<T>): Promise<T>;
+        delete(): Promise<void>;
+        deleteQuietly(): Promise<void>;
+        refresh(): Promise</*elided*/ any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(fields: undefined, raw: true): {
+            [key: string]: LucidRow | LucidRow[];
+        };
+        serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
+        toObject(): import("@adonisjs/lucid/types/model").ModelObject;
+        toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
+        related<Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations</*elided*/ any>>(relation: Name_2): /*elided*/ any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? /*elided*/ any[Name_2]["client"] : never;
+    };
+    find: <T extends LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    all: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
+    connection?: string | undefined;
+    readonly booted: boolean;
+    $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
+    $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
+    $computedDefinitions: Map<string, import("@adonisjs/lucid/types/model").ComputedOptions>;
+    primaryKey: string;
+    table: string;
+    selfAssignPrimaryKey: boolean;
+    $adapter: import("@adonisjs/lucid/types/model").AdapterContract;
+    useAdapter: (adapter: import("@adonisjs/lucid/types/model").AdapterContract) => void;
+    $hooks: import("@poppinss/hooks").default<any>;
+    $keys: {
+        attributesToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        attributesToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        columnsToSerialized: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
+        serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
+    };
+    $createFromAdapterResult: <T extends LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
+    $createMultipleFromAdapterResult: <T extends LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
+    $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
+    $hasColumn: (name: string) => boolean;
+    $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
+    $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
+    $hasComputed: (name: string) => boolean;
+    $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
+    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $hasRelation: (name: string) => boolean;
+    $getRelation: {
+        <Model_1 extends LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): InstanceType<Model_1>[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<LucidModel, LucidModel> ? InstanceType<Model_1>[Name_2]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+    };
+    $defineProperty: <Model_1 extends LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
+    boot: () => void;
+    before: {
+        <Model_1 extends LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<ModelQueryBuilderContract<Model_1>, Event>): void;
+        <Model_1 extends LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[ModelQueryBuilderContract<Model_1>, ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
+    };
+    after: {
+        <Model_1 extends LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
+        <Model_1 extends LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
+        <Model_1 extends LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
+    };
+    create: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createQuietly: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createMany: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    createManyQuietly: <T extends LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    findOrFail: <T extends LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findBy: {
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+    };
+    findByOrFail: {
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+    };
+    findManyBy: {
+        <T extends LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+    };
+    first: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    firstOrFail: <T extends LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findMany: <T extends LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    firstOrNew: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    firstOrCreate: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    updateOrCreate: <T extends LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    fetchOrNewUpMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    fetchOrCreateMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    updateOrCreateMany: <T extends LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    query: <Model_1 extends LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => ModelQueryBuilderContract<Model_1, Result>;
     transaction: import("@adonisjs/lucid/types/database").TransactionFn;
     truncate: (cascade?: boolean) => Promise<void>;
 } & Model;

package/build/src/mixins/has_permissions.js

@@ -1,4 +1,16 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { manyToMany, hasMany } from '@adonisjs/lucid/orm';
 import { Acl } from '../acl.js';
+import Role from '../models/role.js';
+import { ModelRole, Permission } from '../../index.js';
+import ModelPermission from '../models/model_permission.js';
+import { morphMap } from '@holoyan/morph-map-js';
+import { applyTargetRestriction, destructTarget } from '../services/helper.js';
 export function hasPermissions() {
     return (superclass) => {
         class HasPermissionsMixin extends superclass {
@@ -295,3 +307,102 @@ export function hasPermissions() {
         return HasPermissionsMixin;
     };
 }
+export function permissionQueryHelpers() {
+    return (superclass) => {
+        class QueryHelpersMixin extends superclass {
+            _whereRoles(query, targetClass, ...roles) {
+                return query.whereHas(
+                // @ts-ignore
+                '_roles', (rolesQuery) => {
+                    rolesQuery.whereIn('slug', roles).where('model_type', morphMap.getAlias(targetClass));
+                });
+            }
+            _whereDirectPermissions(query, targetClass, permissions, target) {
+                return query.whereHas(
+                // @ts-ignore
+                '_permissions', (permissionsQuery) => {
+                    const entity = destructTarget(morphMap, target);
+                    permissionsQuery
+                        .whereIn('slug', permissions)
+                        .where('model_type', morphMap.getAlias(targetClass))
+                        .whereNotExists((subQuery) => {
+                        subQuery
+                            .from(Permission.table + ' as p2')
+                            .leftJoin(ModelPermission.table + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
+                            .where('p2.allowed', false)
+                            .whereRaw('p2.slug=' + Permission.table + '.slug')
+                            .whereRaw('p2.scope=' + Permission.table + '.scope')
+                            .whereColumn('mp2.model_id', targetClass.table + '.id')
+                            .where('mp2.model_type', morphMap.getAlias(targetClass))
+                            .select('p2.slug')
+                            .groupBy('p2.slug');
+                    });
+                    applyTargetRestriction(Permission.table, permissionsQuery, entity.targetClass, entity.targetId);
+                });
+            }
+            _whereRolePermissions(query, targetClass, permissions, target) {
+                return query.whereHas(
+                // @ts-ignore
+                '_model_roles', (rolesQuery) => {
+                    const entity = destructTarget(morphMap, target);
+                    rolesQuery
+                        .where(ModelRole.table + '.model_type', morphMap.getAlias(targetClass))
+                        .join(ModelPermission.table + ' as mp', 'mp.model_id', '=', ModelRole.table + '.role_id')
+                        .where('mp.model_type', 'roles')
+                        .join(Permission.table + ' as p', 'p.id', '=', 'mp.permission_id')
+                        .whereIn('p.slug', permissions)
+                        .whereNotExists((subQuery) => {
+                        subQuery
+                            .from(Permission.table + ' as p2')
+                            .leftJoin(ModelPermission.table + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
+                            .where('p2.allowed', false)
+                            .whereRaw('p2.slug=' + 'p.slug')
+                            .whereRaw('p2.scope=' + 'p.scope')
+                            .whereColumn('mp2.model_id', targetClass.table + '.id')
+                            .where('mp2.model_type', morphMap.getAlias(targetClass))
+                            .select('p2.slug')
+                            .groupBy('p2.slug');
+                    });
+                    applyTargetRestriction('p', rolesQuery, entity.targetClass, entity.targetId);
+                });
+            }
+            _wherePermissions(query, targetClass, permissions, target) {
+                query
+                    .where((subQuery) => {
+                    this._whereDirectPermissions(subQuery, targetClass, permissions, target);
+                })
+                    .orWhere((subQuery) => {
+                    this._whereRolePermissions(subQuery, targetClass, permissions, target);
+                });
+            }
+        }
+        __decorate([
+            manyToMany(() => Role, {
+                localKey: 'id',
+                relatedKey: 'id',
+                pivotForeignKey: 'model_id',
+                pivotRelatedForeignKey: 'role_id',
+                pivotTable: 'model_roles',
+                pivotColumns: ['model_type'],
+                pivotTimestamps: true,
+            })
+        ], QueryHelpersMixin.prototype, "_roles", void 0);
+        __decorate([
+            manyToMany(() => Permission, {
+                localKey: 'id',
+                relatedKey: 'id',
+                pivotForeignKey: 'model_id',
+                pivotRelatedForeignKey: 'permission_id',
+                pivotTable: 'model_permissions',
+                pivotColumns: ['model_type'],
+                pivotTimestamps: true,
+            })
+        ], QueryHelpersMixin.prototype, "_permissions", void 0);
+        __decorate([
+            hasMany(() => ModelRole, {
+                foreignKey: 'modelId',
+            })
+        ], QueryHelpersMixin.prototype, "_model_roles", void 0);
+        return QueryHelpersMixin;
+    };
+}

package/build/src/models/permission.js

@@ -6,7 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { v4 as uuidv4 } from 'uuid';
 import { BaseModel, beforeCreate, column } from '@adonisjs/lucid/orm';
-export default class Permission extends BaseModel {
+import { MorphMap } from '@holoyan/morph-map-js';
+let Permission = class Permission extends BaseModel {
     static uuidSupport = false;
     static assignUuid(permission) {
         if (this.uuidSupport) {
@@ -16,7 +17,7 @@ export default class Permission extends BaseModel {
     getModelId() {
         return this.id;
     }
-}
+};
 __decorate([
     column({ isPrimary: true })
 ], Permission.prototype, "id", void 0);
@@ -47,3 +48,7 @@ __decorate([
 __decorate([
     beforeCreate()
 ], Permission, "assignUuid", null);
+Permission = __decorate([
+    MorphMap('permissions')
+], Permission);
+export default Permission;

package/build/src/models/role.js

@@ -6,7 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { BaseModel, beforeCreate, column } from '@adonisjs/lucid/orm';
 import { v4 as uuidv4 } from 'uuid';
-export default class Role extends BaseModel {
+import { MorphMap } from '@holoyan/morph-map-js';
+let Role = class Role extends BaseModel {
     static uuidSupport = false;
     static assignUuid(role) {
         if (this.uuidSupport) {
@@ -16,7 +17,7 @@ export default class Role extends BaseModel {
     getModelId() {
         return this.id;
     }
-}
+};
 __decorate([
     column({ isPrimary: true })
 ], Role.prototype, "id", void 0);
@@ -47,3 +48,7 @@ __decorate([
 __decorate([
     beforeCreate()
 ], Role, "assignUuid", null);
+Role = __decorate([
+    MorphMap('roles')
+], Role);
+export default Role;

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

@@ -1,4 +1,7 @@
-import { AclModel, MorphInterface } from '../types.js';
+import { AclModel, ModelIdType, MorphInterface, PermissionInterface } from '../types.js';
+import type { ManyToManySubQueryBuilderContract, RelationSubQueryBuilderContract } from '@adonisjs/lucid/types/relations';
+import { ModelRole, Permission } from '../../index.js';
+import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
 export declare function formatList(models: (string | number | any)[]): {
     slugs: string[];
     ids: number[];
@@ -11,10 +14,11 @@ export declare function formatStringNumbers(models: string | number | any): {
     slugs: string[];
     ids: number[];
 };
-export declare function destructTarget(map: MorphInterface, target?: AclModel | Function): Promise<{
+export declare function destructTarget(map: MorphInterface, target?: AclModel | Function): {
     targetClass: null;
     targetId: null;
 } | {
     targetClass: string;
-    targetId: import("../types.js").ModelIdType | null;
-}>;
+    targetId: ModelIdType | null;
+};
+export declare function applyTargetRestriction(table: string, q: ManyToManySubQueryBuilderContract<typeof Permission> | ModelQueryBuilderContract<typeof Permission, PermissionInterface> | RelationSubQueryBuilderContract<typeof ModelRole>, entityType: string | null, entityId: ModelIdType | null): void;

package/build/src/services/helper.js

@@ -47,7 +47,7 @@ export function formatStringNumbers(models) {
     }
     return { slugs, ids };
 }
-export async function destructTarget(map, target) {
+export function destructTarget(map, target) {
     if (!target) {
         return {
             targetClass: null,
@@ -62,3 +62,21 @@ export async function destructTarget(map, target) {
 function isAclModelInterface(obj) {
     return typeof obj === 'object' && typeof obj.getModelId === 'function';
 }
+export function applyTargetRestriction(table, q, entityType, entityId) {
+    if (entityType) {
+        q.where((query) => {
+            query.where(table + '.entity_type', entityType).orWhere(table + '.entity_type', '*');
+        });
+        if (entityId) {
+            q.where((query) => {
+                query.where(table + '.entity_id', entityId).orWhereNull(table + '.entity_id');
+            });
+        }
+        else {
+            q.whereNull(table + '.entity_id');
+        }
+    }
+    else {
+        q.where(table + '.entity_type', '*').whereNull(table + '.entity_id');
+    }
+}

package/build/src/services/models/model_has_role_permissions.js

@@ -186,22 +186,22 @@ export class ModelHasRolePermissions extends BaseAdapter {
      * @param target
      */
     async hasAllPermissions(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         return await this.permissionService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async hasAnyPermission(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         return await this.permissionService.hasAny(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async hasAnyDirectPermission(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         return await this.permissionService.hasAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async hasDirectPermission(permission, target) {
         return this.hasAnyDirectPermission([permission], target);
     }
     async hasAllPermissionsDirect(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         return await this.permissionService.hasAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     can(permission, target) {
@@ -227,7 +227,7 @@ export class ModelHasRolePermissions extends BaseAdapter {
      * @param target
      */
     async assignDirectAllPermissions(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const assigned = await this.permissionService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
         this.fire(PermissionsAttachedToModelEvent, assigned.map((item) => item.permissionId), this.model);
         return assigned;
@@ -282,7 +282,7 @@ export class ModelHasRolePermissions extends BaseAdapter {
      * @param target
      */
     async revokeAllPermissions(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const revoked = this.permissionService.revokeAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
         this.fire(PermissionsDetachedFromModelEvent, permissions, this.model);
         return revoked;
@@ -320,7 +320,7 @@ export class ModelHasRolePermissions extends BaseAdapter {
      * @param target
      */
     async forbidAll(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const forbade = await this.permissionService.forbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
         this.fire(PermissionsForbadeEvent, forbade.map((item) => item.permissionId), this.model);
     }
@@ -329,7 +329,7 @@ export class ModelHasRolePermissions extends BaseAdapter {
      * @param target
      */
     async unforbidAll(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const unforbade = await this.permissionService.unforbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
         if (unforbade.length) {
             this.fire(PermissionsUnForbadeEvent, unforbade.map((item) => item.permissionId), this.model);

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

@@ -84,7 +84,7 @@ export default class PermissionHasModelRoles extends BaseAdapter {
             }
             role = String(r.id);
         }
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const attached = await this.permissionService.giveAll(this.map.getAlias(this.roleClassName), role, [this.permission.slug], entity.targetClass, entity.targetId, true);
         if (attached.length > 0) {
             this.fire(PermissionsAttachedToRoleEvent, attached.map((item) => item.permissionId), role);

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

@@ -1,4 +1,5 @@
 import BaseService from '../base_service.js';
+import { applyTargetRestriction } from '../helper.js';
 export default class PermissionsService extends BaseService {
     options;
     scope;
@@ -229,6 +230,7 @@ export default class PermissionsService extends BaseService {
             directPermissions: this.map.getAlias(this.roleClassName) === modelType,
             permissionSlugs: slugs,
             permissionIds: ids,
+            includeForbiddings: true,
         }).distinct(this.permissionTable + '.id');
         const r = await q.select(this.permissionTable + '.id');
         // @ts-ignore
@@ -245,6 +247,7 @@ export default class PermissionsService extends BaseService {
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
+            includeForbiddings: true,
         }).distinct(this.permissionTable + '.id');
         const r = await q.select(this.permissionTable + '.id');
         return r.length >= permission.length;
@@ -260,6 +263,7 @@ export default class PermissionsService extends BaseService {
             directPermissions: true,
             permissionSlugs: slugs,
             permissionIds: ids,
+            includeForbiddings: true,
         }).distinct(this.permissionTable + '.id');
         const r = await q.select(this.permissionTable + '.id');
         // @ts-ignore
@@ -393,16 +397,20 @@ export default class PermissionsService extends BaseService {
         const q = this.permissionQuery.leftJoin(this.modelPermissionTable + ' as mp', 'mp.permission_id', '=', this.permissionTable + '.id');
         if (modelId && modelType) {
             if (directPermissions) {
+                // check direct-assigned permissions
                 q.where('mp.model_type', modelType).where('mp.model_id', modelId);
             }
             else {
+                //
                 q.leftJoin(this.modelRoleTable + ' as mr', (joinQuery) => {
                     joinQuery.onVal('mr.model_type', modelType).onVal('mr.model_id', modelId);
                 });
                 if (conditions.throughRoles) {
+                    // only through roles
                     q.whereRaw('mr.role_id=mp.model_id').where('mp.model_type', 'roles');
                 }
                 else {
+                    // check direct-assigned permissions and through roles
                     q.where((subQuery) => {
                         subQuery
                             .where((query) => {
@@ -410,9 +418,6 @@ export default class PermissionsService extends BaseService {
                         })
                             .orWhere((query) => {
                             query.whereRaw('mr.role_id=mp.model_id').where('mp.model_type', 'roles');
-                            // query
-                            //   .whereRaw('CAST(mr.role_id AS CHAR)=mp.model_id')
-                            //   .where('mp.model_type', 'roles')
                         });
                     });
                 }
@@ -489,22 +494,7 @@ export default class PermissionsService extends BaseService {
         return q;
     }
     applyTargetRestriction(table, q, entityType, entityId) {
-        if (entityType) {
-            q.where((query) => {
-                query.where(table + '.entity_type', entityType).orWhere(table + '.entity_type', '*');
-            });
-            if (entityId) {
-                q.where((query) => {
-                    query.where(table + '.entity_id', entityId).orWhereNull(table + '.entity_id');
-                });
-            }
-            else {
-                q.whereNull(table + '.entity_id');
-            }
-        }
-        else {
-            q.where(table + '.entity_type', '*').whereNull(table + '.entity_id');
-        }
+        applyTargetRestriction(table, q, entityType, entityId);
     }
     applyScopes(q) {
         q.where(this.permissionTable + '.scope', this.scope.get());

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

@@ -71,7 +71,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
         return result;
     }
     async hasPermission(permission, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = 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;
     }
@@ -82,7 +82,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
      * @returns
      */
     async hasAllPermissions(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = 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;
     }
@@ -93,7 +93,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
      * @returns
      */
     async hasAnyPermissions(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = 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;
     }
@@ -112,7 +112,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
         return this.hasAnyPermissions(permissions);
     }
     async forbidden(permission, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         return this.permissionService.forbidden(this.map.getAlias(this.role), this.role.getModelId(), permission, entity.targetClass, entity.targetId);
     }
     /**
@@ -144,7 +144,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
      * @param target
      */
     async giveAll(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const attached = await this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId, true);
         if (attached.length > 0) {
             this.fire(PermissionsAttachedToRoleEvent, attached.map((item) => item.permissionId), this.role.getModelId());
@@ -182,7 +182,7 @@ export class RoleHasModelPermissions extends BaseAdapter {
         return this.revokeAll([permission]);
     }
     async revokeAll(permissions, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = destructTarget(this.map, target);
         const revoked = await this.permissionService.revokeAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
         if (revoked.length > 0) {
             this.fire(PermissionsDetachedFromRoleEvent, permissions, this.role.getModelId());
@@ -211,11 +211,11 @@ export class RoleHasModelPermissions extends BaseAdapter {
         return this.giveAll(permissions, target);
     }
     async forbid(permission, target) {
-        const entity = await destructTarget(this.map, target);
+        const entity = 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);
+        const entity = destructTarget(this.map, target);
         return this.permissionService.unforbidAll(this.map.getAlias(this.role), this.role.getModelId(), [permission], entity.targetClass, entity.targetId);
     }
 }

package/build/src/types.d.ts

@@ -69,9 +69,6 @@ export interface ModelPermissionsQuery extends AclModelQuery {
     entity: Entity;
     throughRoles: boolean;
 }
-export interface MorphMapInterface {
-    [key: string]: any;
-}
 export interface MorphInterface {
     set(alias: string, target: any): void;
     get(alias: string): any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holoyan/adonisjs-permissions",
-  "description": "Adonisjs roles and permissions system",
-  "version": "1.1.0",
+  "description": "AdonisJs roles and permissions system",
+  "version": "1.3.0",
   "engines": {
     "node": ">=18.16.0"
   },
@@ -72,9 +72,9 @@
   "peerDependencies": {
     "@adonisjs/core": "^6.2.0",
     "@adonisjs/lucid": "^21.0.0",
+    "@types/uuid": "^10.0.0",
     "luxon": "^3.4.4",
-    "uuid": "^10.0.0",
-    "@types/uuid": "^10.0.0"
+    "uuid": "^10.0.0"
   },
   "publishConfig": {
     "access": "public",
@@ -98,5 +98,8 @@
   "eslintConfig": {
     "extends": "@adonisjs/eslint-config/package"
   },
-  "prettier": "@adonisjs/prettier-config"
+  "prettier": "@adonisjs/prettier-config",
+  "dependencies": {
+    "@holoyan/morph-map-js": "^0.1.1"
+  }
 }

package/build/src/morph_map.d.ts

@@ -1,11 +0,0 @@
-import { MorphInterface } from './types.js';
-export default class MorphMap implements MorphInterface {
-    private _map;
-    private static _instance?;
-    static create(): MorphMap;
-    set(alias: string, target: any): void;
-    get(alias: string): any;
-    has(alias: string): boolean;
-    hasTarget(target: any): boolean;
-    getAlias(target: any): string;
-}

package/build/src/morph_map.js

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