@holoyan/adonisjs-permissions 0.1.0 → 0.5.0

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

@@ -1,13 +1,46 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
 import Permission from '../models/permission.js';
-declare const _default: <Model extends NormalizeConstructor<import("@adonisjs/lucid/types/model").LucidModel>>(superclass: Model) => {
+import { AclModel, RoleInterface } from '../types.js';
+export declare function hasPermissions(): <Model extends NormalizeConstructor<import("@adonisjs/lucid/types/model").LucidModel>>(superclass: Model) => {
     new (...args: any[]): {
-        getMorphMapName(): string;
         getModelId(): number;
-        /**
-         * return all permissions including global, direct
-         */
-        permissions(): Promise<Permission[] | null>;
+        roles(): Promise<import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        hasRole(role: string | RoleInterface): Promise<boolean>;
+        hasAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
+        hasAnyRole(...roles: (string | RoleInterface)[]): Promise<boolean>;
+        assignRole(role: string | RoleInterface): Promise<boolean>;
+        revokeRole(role: string | number | RoleInterface): Promise<boolean>;
+        revokeAllRoles(...roles: (string | number | RoleInterface)[]): Promise<boolean>;
+        permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        onResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        containsPermission(permission: string | Permission): Promise<boolean>;
+        containsAllPermissions(permissions: (string | Permission)[]): Promise<boolean>;
+        containsAnyPermission(permissions: (string | Permission)[]): Promise<boolean>;
+        containsDirectPermission(permission: string | Permission): Promise<boolean>;
+        containsAllPermissionsDirectly(permissions: (string | Permission)[]): Promise<boolean>;
+        containsAnyPermissionDirectly(permissions: (string | Permission)[]): Promise<boolean>;
+        hasPermission(permission: string | Permission, target?: AclModel | Function): Promise<boolean>;
+        hasAllPermissions(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        hasAnyPermission(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        hasAnyDirectPermission(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        hasDirectPermission(permission: string | Permission, target?: AclModel | Function): Promise<boolean>;
+        hasAllPermissionsDirect(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        can(permission: string | Permission, target?: AclModel | Function): Promise<boolean>;
+        canAll(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        canAny(permissions: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
+        assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        allow(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
+        revokeAllPermissions(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+        flushPermissions(): Promise<any[]>;
+        flush(): Promise<boolean>;
+        forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        forbidAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        unforbidAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+        unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;
         $extras: import("@adonisjs/lucid/types/model").ModelObject;
         $original: import("@adonisjs/lucid/types/model").ModelObject;
@@ -66,14 +99,14 @@ declare const _default: <Model extends NormalizeConstructor<import("@adonisjs/lu
         related<Name_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? 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 | undefined) => Promise<InstanceType<T> | null>;
+    all: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_1>[]>;
+    namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
     readonly booted: boolean;
-    boot: () => void;
     $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;
     connection?: string | undefined;
-    namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
     table: string;
     selfAssignPrimaryKey: boolean;
     $adapter: import("@adonisjs/lucid/types/model").AdapterContract;
@@ -87,8 +120,8 @@ declare const _default: <Model extends NormalizeConstructor<import("@adonisjs/lu
         serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
         serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
     };
-    $createFromAdapterResult: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, result?: import("@adonisjs/lucid/types/model").ModelObject | undefined, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_1> | null;
-    $createMultipleFromAdapterResult: <T_2 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_2, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_2>[];
+    $createFromAdapterResult: <T_2 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_2, result?: import("@adonisjs/lucid/types/model").ModelObject | undefined, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_2> | null;
+    $createMultipleFromAdapterResult: <T_3 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_3, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_3>[];
     $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;
@@ -102,6 +135,7 @@ declare const _default: <Model extends NormalizeConstructor<import("@adonisjs/lu
         <Model_2 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_2, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
     };
     $defineProperty: <Model_3 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_3>(this: Model_3, propertyName: Prop, defaultValue: Model_3[Prop], strategy: "inherit" | "define" | ((value: Model_3[Prop]) => Model_3[Prop])) => void;
+    boot: () => void;
     before: {
         <Model_4 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_4, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_4, InstanceType<Model_4>>, Event_1>): void;
         <Model_5 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_5, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_5, InstanceType<Model_5>>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_5, InstanceType<Model_5>>], "paginate">): void;
@@ -112,22 +146,20 @@ declare const _default: <Model extends NormalizeConstructor<import("@adonisjs/lu
         <Model_8 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_8, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_8>>, "paginate">): void;
         <Model_9 extends import("@adonisjs/lucid/types/model").LucidModel, Event_3 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_9, event: Event_3, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_9>, Event_3>): void;
     };
-    create: <T_3 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_3, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_3>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_3>>;
-    createMany: <T_4 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_4, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_4>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_4>[]>;
-    findOrFail: <T_5 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_5, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_5>>;
-    findBy: <T_6 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_6, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_6> | null>;
-    findByOrFail: <T_7 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_7, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_7>>;
-    first: <T_8 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_8, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_8> | null>;
-    firstOrFail: <T_9 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_9, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_9>>;
-    findMany: <T_10 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_10, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_10>[]>;
-    firstOrNew: <T_11 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_11, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_11>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_11>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_11>>;
-    firstOrCreate: <T_12 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_12, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_12>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_12>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_12>>;
-    updateOrCreate: <T_13 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_13, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_13>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_13>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_13>>;
-    fetchOrNewUpMany: <T_14 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_14, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_14>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_14>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_14>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_14>[]>;
-    fetchOrCreateMany: <T_15 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_15, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_15>[]>;
-    updateOrCreateMany: <T_16 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_16, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_16>[]>;
-    all: <T_17 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_17, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_17>[]>;
+    create: <T_4 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_4, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_4>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_4>>;
+    createMany: <T_5 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_5, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_5>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_5>[]>;
+    findOrFail: <T_6 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_6, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_6>>;
+    findBy: <T_7 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_7, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_7> | null>;
+    findByOrFail: <T_8 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_8, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_8>>;
+    first: <T_9 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_9, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_9> | null>;
+    firstOrFail: <T_10 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_10, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_10>>;
+    findMany: <T_11 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_11, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_11>[]>;
+    firstOrNew: <T_12 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_12, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_12>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_12>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_12>>;
+    firstOrCreate: <T_13 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_13, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_13>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_13>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_13>>;
+    updateOrCreate: <T_14 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_14, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_14>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_14>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_14>>;
+    fetchOrNewUpMany: <T_15 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_15, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_15>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_15>[]>;
+    fetchOrCreateMany: <T_16 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_16, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_16>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_16>[]>;
+    updateOrCreateMany: <T_17 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_17, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_17>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_17>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_17>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_17>[]>;
     query: <Model_10 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_10>>(this: Model_10, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_10, Result>;
     truncate: (cascade?: boolean | undefined) => Promise<void>;
 } & Model;
-export default _default;

package/build/src/mixins/has_permissions.js

@@ -1,19 +1,124 @@
-import PermissionsService from '../services/permissions/permissions_service.js';
-export default (superclass) => {
-    class HasPermissionsMixin extends superclass {
-        getMorphMapName() {
-            throw new Error('method getMorphMapName must be implemented in target model, which will return string alias for model class');
+import { Acl } from '../acl.js';
+export function hasPermissions() {
+    return (superclass) => {
+        class HasPermissionsMixin extends superclass {
+            getModelId() {
+                throw new Error('method getModelId must be implemented in target model, which will return key for current object');
+            }
+            roles() {
+                return Acl.model(this).roles();
+            }
+            hasRole(role) {
+                return Acl.model(this).hasRole(role);
+            }
+            hasAllRoles(...roles) {
+                return Acl.model(this).hasAllRoles(...roles);
+            }
+            hasAnyRole(...roles) {
+                return Acl.model(this).hasAnyRole(...roles);
+            }
+            assignRole(role) {
+                return Acl.model(this).assignRole(role);
+            }
+            revokeRole(role) {
+                return Acl.model(this).revokeRole(role);
+            }
+            revokeAllRoles(...roles) {
+                return Acl.model(this).revokeAllRoles(...roles);
+            }
+            // roles related section END
+            // permissions related section BEGIN
+            permissions(includeForbiddings = false) {
+                return Acl.model(this).permissions(includeForbiddings);
+            }
+            globalPermissions(includeForbiddings = false) {
+                return Acl.model(this).globalPermissions(includeForbiddings);
+            }
+            async onResourcePermissions(includeForbiddings = false) {
+                return Acl.model(this).onResourcePermissions(includeForbiddings);
+            }
+            async directGlobalPermissions(includeForbiddings = false) {
+                return Acl.model(this).directGlobalPermissions(includeForbiddings);
+            }
+            async directResourcePermissions(includeForbiddings = false) {
+                return Acl.model(this).directResourcePermissions(includeForbiddings);
+            }
+            async containsPermission(permission) {
+                return Acl.model(this).containsPermission(permission);
+            }
+            async containsAllPermissions(permissions) {
+                return Acl.model(this).containsAllPermissions(permissions);
+            }
+            async containsAnyPermission(permissions) {
+                return Acl.model(this).containsAnyPermission(permissions);
+            }
+            async containsDirectPermission(permission) {
+                return Acl.model(this).containsDirectPermission(permission);
+            }
+            async containsAllPermissionsDirectly(permissions) {
+                return Acl.model(this).containsAllPermissionsDirectly(permissions);
+            }
+            async containsAnyPermissionDirectly(permissions) {
+                return Acl.model(this).containsAnyPermissionDirectly(permissions);
+            }
+            async hasPermission(permission, target) {
+                return Acl.model(this).hasPermission(permission, target);
+            }
+            async hasAllPermissions(permissions, target) {
+                return Acl.model(this).hasAllPermissions(permissions, target);
+            }
+            async hasAnyPermission(permissions, target) {
+                return Acl.model(this).hasAnyPermission(permissions, target);
+            }
+            async hasAnyDirectPermission(permissions, target) {
+                return Acl.model(this).hasAnyDirectPermission(permissions, target);
+            }
+            async hasDirectPermission(permission, target) {
+                return Acl.model(this).hasDirectPermission(permission, target);
+            }
+            async hasAllPermissionsDirect(permissions, target) {
+                return Acl.model(this).hasAllPermissionsDirect(permissions, target);
+            }
+            can(permission, target) {
+                return Acl.model(this).can(permission, target);
+            }
+            canAll(permissions, target) {
+                return Acl.model(this).canAll(permissions, target);
+            }
+            canAny(permissions, target) {
+                return Acl.model(this).canAny(permissions, target);
+            }
+            async assignDirectPermission(permission, target) {
+                return Acl.model(this).assignDirectPermission(permission, target);
+            }
+            allow(permission, target) {
+                return Acl.model(this).allow(permission, target);
+            }
+            async revokePermission(permission, target) {
+                return Acl.model(this).revokePermission(permission, target);
+            }
+            async revokeAllPermissions(permissions, target) {
+                return Acl.model(this).revokeAllPermissions(permissions, target);
+            }
+            async flushPermissions() {
+                return Acl.model(this).flushPermissions();
+            }
+            async flush() {
+                return Acl.model(this).flush();
+            }
+            async forbid(permission, target) {
+                return Acl.model(this).forbid(permission, target);
+            }
+            async forbidAll(permissions, target) {
+                return Acl.model(this).forbidAll(permissions, target);
+            }
+            async unforbidAll(permissions, target) {
+                return Acl.model(this).unforbidAll(permissions, target);
+            }
+            async unforbid(permission, target) {
+                return Acl.model(this).unforbid(permission, target);
+            }
         }
-        getModelId() {
-            throw new Error('method getModelId must be implemented in target model, which will return key for current object');
-        }
-        /**
-         * return all permissions including global, direct
-         */
-        permissions() {
-            const service = new PermissionsService();
-            return service.all(this.getMorphMapName(), this.getModelId());
-        }
-    }
-    return HasPermissionsMixin;
-};
+        return HasPermissionsMixin;
+    };
+}

package/build/src/model_manager.d.ts

@@ -0,0 +1,7 @@
+import { BaseModel } from '@adonisjs/lucid/orm';
+export default class ModelManager {
+    private models;
+    setModel(key: string, className: typeof BaseModel): void;
+    has(key: string): boolean;
+    getModel(key: string): import("@adonisjs/lucid/types/model").LucidModel;
+}

package/build/src/model_manager.js

@@ -0,0 +1,15 @@
+export default class ModelManager {
+    models = {};
+    setModel(key, className) {
+        this.models[key] = className;
+    }
+    has(key) {
+        return key in this.models;
+    }
+    getModel(key) {
+        if (key in this.models) {
+            return this.models[key];
+        }
+        throw new Error('Model not defined');
+    }
+}

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

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

package/build/src/models/permission.js

@@ -6,15 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { BaseModel, column } from '@adonisjs/lucid/orm';
 import config from '@adonisjs/core/services/config';
-import { MorphMap } from '../decorators.js';
-let Permission = class Permission extends BaseModel {
+export default class Permission extends BaseModel {
     static get table() {
         return config.get('permissions.permissionsConfig.tables.permissions');
     }
     getModelId() {
         return this.id;
     }
-};
+}
 __decorate([
     column({ isPrimary: true })
 ], Permission.prototype, "id", void 0);
@@ -42,7 +41,3 @@ __decorate([
 __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true })
 ], Permission.prototype, "updatedAt", void 0);
-Permission = __decorate([
-    MorphMap(config.get('permissions.permissionsConfig.morphMaps.permissions'))
-], Permission);
-export default Permission;

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

@@ -6,7 +6,7 @@ export default class Role extends BaseModel implements AclModelInterface {
     getModelId(): number;
     id: number;
     slug: string;
-    title: string;
+    title: string | null;
     entityType: string;
     entityId: number | null;
     scope: number;

package/build/src/models/role.js

@@ -6,15 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { BaseModel, column } from '@adonisjs/lucid/orm';
 import config from '@adonisjs/core/services/config';
-import { MorphMap } from '../decorators.js';
-let Role = class Role extends BaseModel {
+export default class Role extends BaseModel {
     static get table() {
         return config.get('permissions.permissionsConfig.tables.roles');
     }
     getModelId() {
         return this.id;
     }
-};
+}
 __decorate([
     column({ isPrimary: true })
 ], Role.prototype, "id", void 0);
@@ -42,7 +41,3 @@ __decorate([
 __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true })
 ], Role.prototype, "updatedAt", void 0);
-Role = __decorate([
-    MorphMap(config.get('permissions.permissionsConfig.morphMaps.roles'))
-], Role);
-export default Role;

package/build/src/morph_map.d.ts

@@ -1,5 +1,8 @@
-export default class MorphMap {
-    private map;
+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;

package/build/src/morph_map.js

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

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

@@ -1,5 +1,4 @@
-import { AclModel } from '../types.js';
-export declare function morphMap(): Promise<import("../morph_map.js").default>;
+import { AclModel, MorphInterface } from '../types.js';
 export declare function formatList(models: (string | number | any)[]): {
     slugs: string[];
     ids: number[];
@@ -12,7 +11,7 @@ export declare function formatStringNumbers(models: string | number | any): {
     slugs: string[];
     ids: number[];
 };
-export declare function destructTarget(target?: AclModel | Function): Promise<{
+export declare function destructTarget(map: MorphInterface, target?: AclModel | Function): Promise<{
     targetClass: null;
     targetId: null;
 } | {

package/build/src/services/helper.js

@@ -1,8 +1,3 @@
-import app from '@adonisjs/core/services/app';
-export async function morphMap() {
-    const map = await app.container.make('morphMap');
-    return map;
-}
 export function formatList(models) {
     let slugs = [];
     let ids = [];
@@ -51,14 +46,13 @@ export function formatStringNumbers(models) {
     }
     return { slugs, ids };
 }
-export async function destructTarget(target) {
+export async function destructTarget(map, target) {
     if (!target) {
         return {
             targetClass: null,
             targetId: null,
         };
     }
-    const map = await morphMap();
     return {
         targetClass: map.getAlias(target),
         targetId: isAclModelInterface(target) ? target.getModelId() : null,

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

@@ -1,48 +1,50 @@
-import Permission from '../models/permission.js';
-import Role from '../models/role.js';
-import { AclModel } from '../types.js';
+import { AclModel, MorphInterface, PermissionInterface, RoleInterface } from '../types.js';
 import PermissionsService from './permissions/permissions_service.js';
 import RolesService from './roles/roles_service.js';
 export declare class ModelHasRolePermissions {
     private model;
     private roleService;
     private permissionsService;
-    constructor(model: AclModel, roleService: RolesService, permissionsService: PermissionsService);
-    roles(): Promise<Role[]>;
-    hasRole(role: string | Role): Promise<boolean>;
-    hasAllRoles(roles: (string | Role)[]): Promise<boolean>;
-    hasAnyRole(roles: (string | Role)[]): Promise<boolean>;
-    assignRole(role: string | Role): Promise<boolean>;
-    revokeRole(role: string | number | Role): Promise<boolean>;
-    revokeAllRoles(roles: (string | number | Role)[]): Promise<boolean>;
-    permissions(includeForbiddens?: boolean): Promise<Permission[]>;
-    globalPermissions(includeForbiddens?: boolean): Promise<Permission[]>;
-    onResourcePermissions(includeForbiddens?: boolean): Promise<Permission[]>;
-    directGlobalPermissions(includeForbiddens?: boolean): Promise<Permission[]>;
-    directResourcePermissions(includeForbiddens?: boolean): Promise<Permission[]>;
-    containsPermission(permisison: string | Permission): Promise<boolean>;
-    containsAllPermissions(permisisons: (string | Permission)[]): Promise<boolean>;
-    containsAnyPermission(permisisons: (string | Permission)[]): Promise<boolean>;
-    containsDirectPermission(permisison: string | Permission): Promise<boolean>;
-    containsAllPermissionsDirectly(permisisons: (string | Permission)[]): Promise<boolean>;
-    containsAnyPermissionDirectly(permisisons: (string | Permission)[]): Promise<boolean>;
-    hasPermission(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissions(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyPermission(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyDirectPermission(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    hasDirectPermission(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissionsDirect(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    can(permisison: string | Permission, target?: AclModel | Function): Promise<boolean>;
-    canAll(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    canAny(permisisons: (string | Permission)[], target?: AclModel | Function): Promise<boolean>;
-    assignDirectPermission(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
-    allow(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
-    revokePermission(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
-    revokeAllPermissions(permisisons: string[], target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
+    private map;
+    constructor(model: AclModel, roleService: RolesService, permissionsService: PermissionsService, map: MorphInterface);
+    roles(): Promise<import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    hasRole(role: string | RoleInterface): Promise<boolean>;
+    hasAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
+    hasAnyRole(...roles: (string | RoleInterface)[]): Promise<boolean>;
+    assignRole(role: string | RoleInterface): Promise<boolean>;
+    assignAllRoles(...roles: (string | RoleInterface)[]): Promise<boolean>;
+    revokeRole(role: string | number | RoleInterface): Promise<boolean>;
+    revokeAllRoles(...roles: (string | number | RoleInterface)[]): Promise<boolean>;
+    flushRoles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
+    permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    onResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    containsPermission(permission: string | PermissionInterface): Promise<boolean>;
+    containsAllPermissions(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    containsAnyPermission(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    containsDirectPermission(permission: string | PermissionInterface): Promise<boolean>;
+    containsAllPermissionsDirectly(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    containsAnyPermissionDirectly(permissions: (string | PermissionInterface)[]): Promise<boolean>;
+    hasPermission(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissions(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyPermission(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    hasAnyDirectPermission(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    hasDirectPermission(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
+    hasAllPermissionsDirect(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    can(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
+    canAll(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    canAny(permissions: (string | PermissionInterface)[], target?: AclModel | Function): Promise<boolean>;
+    assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    assignDirectAllPermissions(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    allow(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
+    revokeAllPermissions(permissions: string[], target?: AclModel | Function): Promise<any[]>;
     flushPermissions(): Promise<any[]>;
     flush(): Promise<boolean>;
-    forbid(permisison: string, target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
-    forbidAll(permisisons: string[], target?: AclModel | Function): Promise<import("../models/model_permission.js").default[]>;
-    unforbidAll(permisisons: string[], target?: AclModel | Function): Promise<any[]>;
-    unforbid(permisison: string, target?: AclModel | Function): Promise<any[]>;
+    forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    forbidAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    unforbidAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+    unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
 }