@holoyan/adonisjs-permissions 1.2.0 → 1.3.1

package/README.md

@@ -14,8 +14,8 @@ Checkout other AdonisJS packages
 
 ## Release Notes
 
-Version: >= v1.2.0
-* Added [Morph Map](https://github.com/holoyan/morph-map-js) as a dependency to handle polymorphic relations - fixed [#20](https://github.com/holoyan/adonisjs-permissions/issues/20)
+Version: >= v1.3.1
+* Added [canPartially](#checking-partial-permissions) method
 
 ## Table of Contents
 
@@ -25,6 +25,8 @@ Version: >= v1.2.0
 - [Installation](#installation)
 - [Configuration](#configuration)
 - [Mixins](#mixins)
+  - [hasPermissions](#haspermissions-mixin)
+  - [permissionQueryHelpers](#permissionqueryhelpers-mixin)
 - [Support](#support)
   - [Database support](#database-support)
   - [UUID support](#uuid-support)
@@ -143,6 +145,8 @@ export default class Post extends BaseModel implements AclModelInterface {
 
 ## Mixins
 
+### hasPermissions mixin
+
 If you want to be able to call `Acl` methods on a `User` model then consider using `hasPermissions` mixin
 
 ```typescript
@@ -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
@@ -445,6 +504,21 @@ await Acl.role(role).hasAnyPermission(['update', 'read'])
 
 ```
 
+### Checking partial permissions
+
+Sometimes you might want to check if a user has a specific permission on any instance of a model class, rather than checking for global permissions or permissions on a specific instance. For this purpose, you can use the `canPartially` method:
+
+```typescript
+
+const postWithId = await Post.find(id)
+await Acl.model(user).allow('create', postWithId) // allow 'create' on post instance
+
+// This is useful when you want to know if a user has permission on at least one instance
+Acl.model(user).can('create') // will return false
+Acl.model(user).can('create', Post) // will return false
+Acl.model(user).canPartially('create', Post) // will return true because user has a 'create' permission on postWithId instance
+```
+
 ### Middleware
 
 You are free to do your check anywhere, for example we can create [named](https://docs.adonisjs.com/guides/middleware#named-middleware-collection) middleware and do checking
@@ -1273,6 +1347,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

package/build/index.d.ts

@@ -10,5 +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 { 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,5 +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 { hasPermissions } from './src/mixins/has_permissions.js';
+export { hasPermissions, permissionQueryHelpers } from './src/mixins/has_permissions.js';
 export { Scope } from './src/scope.js';

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
@@ -137,18 +142,24 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
          */
         canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
         canAny(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if a model has permission on any instance of a model class
+         * @param permission
+         * @param targetClass
+         */
+        canPartially(permission: string, targetClass: Function): Promise<boolean>;
         /**
          * Check if model has any permission
          * @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 +196,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 +225,152 @@ 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;
+        $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 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 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;
+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;
@@ -231,14 +387,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;
@@ -254,22 +410,22 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<ty
         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 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 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;
@@ -290,59 +446,59 @@ 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>>;
-    createQuietly: <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>[]>;
-    createManyQuietly: <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;

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 {
@@ -192,6 +204,14 @@ export function hasPermissions() {
             canAny(permissions, target) {
                 return Acl.model(this).canAny(permissions, target);
             }
+            /**
+             * Check if a model has permission on any instance of a model class
+             * @param permission
+             * @param targetClass
+             */
+            canPartially(permission, targetClass) {
+                return Acl.model(this).canPartially(permission, targetClass);
+            }
             /**
              * Check if model has any permission
              * @param permission
@@ -295,3 +315,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/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,16 @@ 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;
+/**
+ * Apply target restriction for partial permission checks
+ * This function doesn't check entity_id when only entityType is provided
+ */
+export declare function applyPartialTargetRestriction(table: string, q: ManyToManySubQueryBuilderContract<typeof Permission> | ModelQueryBuilderContract<typeof Permission, PermissionInterface> | RelationSubQueryBuilderContract<typeof ModelRole>, entityType: string): 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,28 @@ 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');
+    }
+}
+/**
+ * Apply target restriction for partial permission checks
+ * This function doesn't check entity_id when only entityType is provided
+ */
+export function applyPartialTargetRestriction(table, q, entityType) {
+    q.where(table + '.entity_type', entityType).whereNotNull(table + '.entity_id');
+}

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

@@ -102,6 +102,24 @@ export declare class ModelHasRolePermissions extends BaseAdapter {
     can(permission: string, target?: AclModel | Function): Promise<boolean>;
     canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
     canAny(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+    /**
+     * Check if model has permission on any instance of a model class
+     * @param permission
+     * @param targetClass
+     */
+    hasPartialPermission(permission: string, targetClass: Function): Promise<boolean>;
+    /**
+     * Check if model has any of the permissions on any instance of a model class
+     * @param permissions
+     * @param targetClass
+     */
+    hasAnyPartialPermission(permissions: string[], targetClass: Function): Promise<boolean>;
+    /**
+     * Check if a model has permission on any instance of a model class
+     * @param permission
+     * @param targetClass
+     */
+    canPartially(permission: string, targetClass: Function): Promise<boolean>;
     /**
      * calls assignDirectAllPermissions()
      * @param permission

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) {
@@ -213,6 +213,31 @@ export class ModelHasRolePermissions extends BaseAdapter {
     canAny(permissions, target) {
         return this.hasAnyPermission(permissions, target);
     }
+    /**
+     * Check if model has permission on any instance of a model class
+     * @param permission
+     * @param targetClass
+     */
+    async hasPartialPermission(permission, targetClass) {
+        return this.hasAnyPartialPermission([permission], targetClass);
+    }
+    /**
+     * Check if model has any of the permissions on any instance of a model class
+     * @param permissions
+     * @param targetClass
+     */
+    async hasAnyPartialPermission(permissions, targetClass) {
+        const entityType = this.map.getAlias(targetClass);
+        return await this.permissionService.hasAnyPartial(this.map.getAlias(this.model), this.model.getModelId(), permissions, entityType);
+    }
+    /**
+     * Check if a model has permission on any instance of a model class
+     * @param permission
+     * @param targetClass
+     */
+    canPartially(permission, targetClass) {
+        return this.hasPartialPermission(permission, targetClass);
+    }
     /**
      * calls assignDirectAllPermissions()
      * @param permission
@@ -227,7 +252,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 +307,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 +345,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 +354,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.d.ts

@@ -57,6 +57,10 @@ export default class PermissionsService extends BaseService {
      * has any of permissions
      */
     hasAny(modelType: string, modelId: ModelIdType, permission: string[], entityType: string | null, entityId: ModelIdType | null): Promise<boolean>;
+    /**
+     * has any of permissions on any instance of a model class
+     */
+    hasAnyPartial(modelType: string, modelId: ModelIdType, permissions: string[], entityType: string): Promise<boolean>;
     /**
      * has all permissions
      */
@@ -109,6 +113,7 @@ export default class PermissionsService extends BaseService {
     reverseModelPermissionQuery(conditions: Partial<ModelPermissionsQuery>): ModelQueryBuilderContract<typeof import("../../models/model_permission.js").default, import("../../models/model_permission.js").default>;
     findAssignableEntity(permission: string[], entityClass: string | null, entityId: ModelIdType | null, allowed: boolean): ModelQueryBuilderContract<typeof Permission, Permission>;
     private applyTargetRestriction;
+    private applyPartialTargetRestriction;
     private applyScopes;
     private applyModelPermissionScopes;
 }

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

@@ -1,4 +1,5 @@
 import BaseService from '../base_service.js';
+import { applyTargetRestriction, applyPartialTargetRestriction } from '../helper.js';
 export default class PermissionsService extends BaseService {
     options;
     scope;
@@ -203,6 +204,27 @@ export default class PermissionsService extends BaseService {
         const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
         return r.length > 0;
     }
+    /**
+     * has any of permissions on any instance of a model class
+     */
+    async hasAnyPartial(modelType, modelId, permissions, entityType) {
+        const { slugs, ids } = this.formatList(permissions);
+        const q = this.modelPermissionQueryWithForbiddenCheck({
+            modelType,
+            modelId,
+            directPermissions: this.map.getAlias(this.roleClassName) === modelType,
+            permissionSlugs: slugs,
+            permissionIds: ids,
+            entity: {
+                type: entityType,
+                id: null,
+            },
+        });
+        // We use applyPartialTargetRestriction which doesn't check entity_id when only entityType is provided
+        this.applyPartialTargetRestriction(this.permissionTable, q, entityType);
+        const r = await q.distinct(this.permissionTable + '.id').select(this.permissionTable + '.id');
+        return r.length > 0;
+    }
     /**
      * has all permissions
      */
@@ -229,6 +251,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 +268,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 +284,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 +418,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 +439,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 +515,10 @@ 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);
+    }
+    applyPartialTargetRestriction(table, q, entityType) {
+        applyPartialTargetRestriction(table, q, entityType);
     }
     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.2.0",
+  "version": "1.3.1",
   "engines": {
     "node": ">=18.16.0"
   },