@holoyan/adonisjs-permissions 0.7.15 → 0.8.17

package/README.md

@@ -41,6 +41,7 @@
   - [Scopes or Multi-tenancy](#scopes-or-multi-tenancy)
     - [The Scope middleware](#the-scope-middleware) 
     - [Default Scope](#default-scope-tenant)
+  - [Transactions](#transactions)
 - [Cheat sheet](#cheat-sheet)
 - [Todo](#todo)
 - [Test](#test)
@@ -964,6 +965,24 @@ Acl.scope('scope_2', forceUpdate) // will override request 1 scope
 
 > Default Scope value is equal to 'default'
 
+### Transactions
+
+In case you want to use `Acl` inside the transaction then you can pass `options` directly to query method.
+
+```typescript
+
+import {Acl} from '@holoyan/adonisjs-permissions'
+
+const trx = await db.transaction()
+
+await Acl.model(user).withQueryOptions({ client: trx }).allow('delete')
+
+// you other code
+
+await trx.commit()
+
+```
+
 
 ## Cheat sheet
 

package/build/src/acl.d.ts

@@ -1,6 +1,6 @@
 import { RoleHasModelPermissions } from './services/roles/role_has_model_permissions.js';
 import { ModelHasRolePermissions } from './services/model_has_role_permissions.js';
-import { AclModel, MorphInterface, PermissionInterface, RoleInterface, ScopeInterface } from './types.js';
+import { AclModel, MorphInterface, OptionsInterface, PermissionInterface, RoleInterface, ScopeInterface } from './types.js';
 import ModelManager from './model_manager.js';
 import EmptyPermission from './services/permissions/empty_permission.js';
 import EmptyRoles from './services/roles/empty_roles.js';
@@ -9,16 +9,26 @@ export declare class AclManager {
     private static map;
     static setModelManager(manager: ModelManager): void;
     static setMorphMap(map: MorphInterface): void;
-    private _scope?;
-    private allowScopeRewriting;
-    constructor(allowScopeRewriting?: boolean);
+    private allowOptionsRewriting;
+    private options;
+    constructor(allowOptionsRewriting: boolean, defaultOptions?: OptionsInterface);
     model(model: AclModel): ModelHasRolePermissions;
     role(): EmptyRoles;
     role(role: RoleInterface): RoleHasModelPermissions;
     permission(): EmptyPermission;
     permission(permission: PermissionInterface): EmptyPermission;
     private createNewScope;
+    /**
+     * changing global options
+     * @param options
+     * @param forceUpdate
+     */
+    withOptions(options: OptionsInterface, forceUpdate?: boolean): this;
+    /**
+     * @param scope
+     * @param forceUpdate
+     */
     scope(scope: ScopeInterface, forceUpdate?: boolean): this;
-    getScope(): ScopeInterface;
+    getScope(): any;
 }
 export declare const Acl: AclManager;

package/build/src/acl.js

@@ -1,11 +1,10 @@
 import { RoleHasModelPermissions } from './services/roles/role_has_model_permissions.js';
 import { ModelHasRolePermissions } from './services/model_has_role_permissions.js';
-import PermissionsService from './services/permissions/permissions_service.js';
-import RolesService from './services/roles/roles_service.js';
 import PermissionHasModelRoles from './services/permissions/permission_has_model_roles.js';
-import ModelService from './services/model_service.js';
+import ModelManager from './model_manager.js';
 import EmptyPermission from './services/permissions/empty_permission.js';
 import EmptyRoles from './services/roles/empty_roles.js';
+import { Scope } from './scope.js';
 export class AclManager {
     static modelManager;
     static map;
@@ -15,53 +14,65 @@ export class AclManager {
     static setMorphMap(map) {
         this.map = map;
     }
-    _scope;
-    allowScopeRewriting = true;
-    constructor(allowScopeRewriting) {
-        if (allowScopeRewriting !== undefined) {
-            this.allowScopeRewriting = allowScopeRewriting;
+    allowOptionsRewriting;
+    options = {};
+    constructor(allowOptionsRewriting, defaultOptions) {
+        this.allowOptionsRewriting = allowOptionsRewriting;
+        // default global scope
+        this.options['scope'] = this.createNewScope();
+        if (defaultOptions) {
+            this.options = { ...this.options, ...defaultOptions };
         }
     }
     model(model) {
-        const scope = this.getScope();
-        const role = AclManager.modelManager.getModel('role');
-        const modelPermission = AclManager.modelManager.getModel('modelPermission');
-        const modelRole = AclManager.modelManager.getModel('modelRole');
-        return new ModelHasRolePermissions(model, new RolesService(role, modelPermission, modelRole, AclManager.map, scope), new PermissionsService(AclManager.modelManager.getModel('permission'), role, modelPermission, modelRole, AclManager.map, scope), AclManager.map, scope);
+        return new ModelHasRolePermissions(AclManager.modelManager, AclManager.map, { ...this.options }, model);
     }
     role(role) {
-        const scope = this.getScope();
-        const roleClass = AclManager.modelManager.getModel('role');
-        const modelPermission = AclManager.modelManager.getModel('modelPermission');
-        const modelRole = AclManager.modelManager.getModel('modelRole');
         if (role) {
-            return new RoleHasModelPermissions(role, new PermissionsService(AclManager.modelManager.getModel('permission'), roleClass, modelPermission, modelRole, AclManager.map, scope), new ModelService(modelPermission, modelRole, AclManager.map), AclManager.map, scope);
+            return new RoleHasModelPermissions(AclManager.modelManager, AclManager.map, { ...this.options }, role);
         }
-        return new EmptyRoles(roleClass, scope);
+        return new EmptyRoles(AclManager.modelManager, AclManager.map, { ...this.options });
     }
     permission(permission) {
-        const scope = this.getScope();
-        const roleClass = AclManager.modelManager.getModel('role');
-        const modelPermission = AclManager.modelManager.getModel('modelPermission');
-        const modelRole = AclManager.modelManager.getModel('modelRole');
         if (permission) {
-            return new PermissionHasModelRoles(permission, new RolesService(roleClass, modelPermission, modelRole, AclManager.map, scope), new PermissionsService(AclManager.modelManager.getModel('permission'), roleClass, modelPermission, modelRole, AclManager.map, scope), new ModelService(modelPermission, modelRole, AclManager.map), modelPermission, modelRole, AclManager.map, scope);
+            return new PermissionHasModelRoles(AclManager.modelManager, AclManager.map, { ...this.options }, permission);
         }
-        return new EmptyPermission(AclManager.modelManager.getModel('permission'), scope);
+        return new EmptyPermission(AclManager.modelManager, AclManager.map, { ...this.options });
     }
     createNewScope() {
         const ScopeClass = AclManager.modelManager.getModel('scope');
-        return new ScopeClass();
+        return new ScopeClass().get();
     }
+    /**
+     * changing global options
+     * @param options
+     * @param forceUpdate
+     */
+    withOptions(options, forceUpdate = false) {
+        if (!this.allowOptionsRewriting && !forceUpdate) {
+            throw new Error('withOptions method call is not available on global Acl object, use AclManager to create new object or use forceUpdate=true');
+        }
+        this.options = { ...this.options, ...options };
+        return this;
+    }
+    /**
+     * @param scope
+     * @param forceUpdate
+     */
     scope(scope, forceUpdate = false) {
-        if (!this.allowScopeRewriting && !forceUpdate) {
+        if (!this.allowOptionsRewriting && !forceUpdate) {
             throw new Error('Scope method call is not available on global Acl object, use AclManager to create new scoped object or use forceUpdate=true');
         }
-        this._scope = scope;
+        this.withOptions({
+            scope,
+        }, forceUpdate);
         return this;
     }
     getScope() {
-        return this._scope || this.createNewScope();
+        return this.options['scope'];
     }
 }
+const modelManager = new ModelManager();
+modelManager.setModel('scope', Scope);
+AclManager.setModelManager(modelManager);
 export const Acl = new AclManager(false);

package/build/src/scope.d.ts

@@ -1,8 +1,8 @@
 import { ScopeInterface } from './types.js';
 export declare class Scope implements ScopeInterface {
     private currentScope;
-    constructor(scope?: string);
     static defaultScope: string;
+    constructor(scope?: string);
     set(scope: string): this;
     get(): string;
     default(): string;

package/build/src/scope.js

@@ -1,12 +1,12 @@
 export class Scope {
     currentScope;
+    static defaultScope = 'default';
     constructor(scope) {
         if (!scope) {
             scope = Scope.defaultScope;
         }
         this.currentScope = scope;
     }
-    static defaultScope = 'default';
     set(scope) {
         this.currentScope = scope;
         return this;

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

@@ -0,0 +1,13 @@
+import { ModelAdapterOptions } from '@adonisjs/lucid/types/model';
+import ModelManager from '../model_manager.js';
+import { MorphInterface, OptionsInterface } from '../types.js';
+export default class BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
+    protected get scope(): any;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface);
+    on(scope: string): this;
+    getScope(): any;
+    withQueryOptions(options: ModelAdapterOptions): this;
+}

package/build/src/services/base_adapter.js

@@ -0,0 +1,24 @@
+export default class BaseAdapter {
+    manager;
+    map;
+    options;
+    get scope() {
+        return this.options['scope'];
+    }
+    constructor(manager, map, options) {
+        this.manager = manager;
+        this.map = map;
+        this.options = options;
+    }
+    on(scope) {
+        this.options['scope'] = scope;
+        return this;
+    }
+    getScope() {
+        return this.scope;
+    }
+    withQueryOptions(options) {
+        this.options['queryOptions'] = options;
+        return this;
+    }
+}

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

@@ -1,4 +1,9 @@
+import { OptionsInterface } from '../types.js';
 export default class BaseService {
+    protected options: OptionsInterface;
+    constructor(options: OptionsInterface);
+    protected getQueryOptions(): any;
+    protected get scope(): any;
     protected formatList(models: (string | number | any)[]): {
         slugs: string[];
         ids: number[];

package/build/src/services/base_service.js

@@ -1,5 +1,15 @@
 import { formatList, formatListStringNumbers, formatStringNumbers } from './helper.js';
 export default class BaseService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    getQueryOptions() {
+        return this.options['queryOptions'] || undefined;
+    }
+    get scope() {
+        return this.options['scope'];
+    }
     formatList(models) {
         return formatList(models);
     }

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

@@ -1,15 +1,16 @@
-import { AclModel, MorphInterface, ScopeInterface } from '../types.js';
-import PermissionsService from './permissions/permissions_service.js';
+import { AclModel, MorphInterface, OptionsInterface } from '../types.js';
 import RolesService from './roles/roles_service.js';
-export declare class ModelHasRolePermissions {
+import BaseAdapter from './base_adapter.js';
+import ModelManager from '../model_manager.js';
+import PermissionService from './permissions/permissions_service.js';
+export declare class ModelHasRolePermissions extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
     private model;
-    private roleService;
-    private permissionsService;
-    private map;
-    private scope;
-    constructor(model: AclModel, roleService: RolesService, permissionsService: PermissionsService, map: MorphInterface, scope: ScopeInterface);
-    on(scope: string): this;
-    getScope(): string;
+    protected roleService: RolesService;
+    protected permissionService: PermissionService;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, model: AclModel);
     roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     hasRole(role: string): Promise<boolean>;
     hasAllRoles(...roles: string[]): Promise<boolean>;
@@ -24,6 +25,10 @@ export declare class ModelHasRolePermissions {
     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>[]>;
     directPermissions(includeForbiddings?: boolean): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    /**
+     * Get permission through roles
+     * @param includeForbiddings
+     */
     rolePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;

package/build/src/services/model_has_role_permissions.js

@@ -1,23 +1,25 @@
+import RolesService from './roles/roles_service.js';
 import { destructTarget, formatList } from './helper.js';
-export class ModelHasRolePermissions {
+import BaseAdapter from './base_adapter.js';
+import PermissionService from './permissions/permissions_service.js';
+export class ModelHasRolePermissions extends BaseAdapter {
+    manager;
+    map;
+    options;
     model;
     roleService;
-    permissionsService;
-    map;
-    scope;
-    constructor(model, roleService, permissionsService, map, scope) {
-        this.model = model;
-        this.roleService = roleService;
-        this.permissionsService = permissionsService;
+    permissionService;
+    constructor(manager, map, options, model) {
+        super(manager, map, options);
+        this.manager = manager;
         this.map = map;
-        this.scope = scope;
-    }
-    on(scope) {
-        this.scope.set(scope);
-        return this;
-    }
-    getScope() {
-        return this.scope.get();
+        this.options = options;
+        this.model = model;
+        const role = manager.getModel('role');
+        const modelPermission = manager.getModel('modelPermission');
+        const modelRole = manager.getModel('modelRole');
+        this.roleService = new RolesService(this.options, role, modelPermission, modelRole, map);
+        this.permissionService = new PermissionService(this.options, manager.getModel('permission'), role, modelPermission, modelRole, map);
     }
     // roles related section BEGIN
     roles() {
@@ -54,50 +56,54 @@ export class ModelHasRolePermissions {
     // roles related section END
     // permissions related section BEGIN
     async permissions(includeForbiddings = false) {
-        return this.permissionsService.all(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.all(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     async globalPermissions(includeForbiddings = false) {
-        return this.permissionsService.global(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.global(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     async onResourcePermissions(includeForbiddings = false) {
-        return this.permissionsService.onResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.onResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     directPermissions(includeForbiddings = false) {
-        return this.permissionsService.direct(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.direct(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
+    /**
+     * Get permission through roles
+     * @param includeForbiddings
+     */
     rolePermissions(includeForbiddings = false) {
-        return this.permissionsService.throughRoles(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.throughRoles(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     async directGlobalPermissions(includeForbiddings = false) {
-        return this.permissionsService.directGlobal(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.directGlobal(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     async directResourcePermissions(includeForbiddings = false) {
-        return this.permissionsService.directResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+        return this.permissionService.directResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
     async containsPermission(permission) {
-        const result = await this.permissionsService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
+        const result = await this.permissionService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
         return result;
     }
     async contains(permission) {
         return this.containsPermission(permission);
     }
     async containsAllPermissions(permissions) {
-        const result = await this.permissionsService.containsAll(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+        const result = await this.permissionService.containsAll(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
     async containsAnyPermission(permissions) {
-        const result = await this.permissionsService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+        const result = await this.permissionService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
     async containsDirectPermission(permission) {
-        const result = await this.permissionsService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
+        const result = await this.permissionService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
         return result;
     }
     containsAllPermissionsDirectly(permissions) {
-        return this.permissionsService.containsAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+        return this.permissionService.containsAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
     }
     async containsAnyPermissionDirectly(permissions) {
-        const result = await this.permissionsService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+        const result = await this.permissionService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
     async hasPermission(permission, target) {
@@ -105,22 +111,22 @@ export class ModelHasRolePermissions {
     }
     async hasAllPermissions(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return await this.permissionsService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        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);
-        return await this.permissionsService.hasAny(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        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);
-        return await this.permissionsService.hasAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        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);
-        return await this.permissionsService.hasAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        return await this.permissionService.hasAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     can(permission, target) {
         return this.hasPermission(permission, target);
@@ -133,11 +139,11 @@ export class ModelHasRolePermissions {
     }
     async assignDirectPermission(permission, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), [permission], entity.targetClass, entity.targetId, true);
+        return this.permissionService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), [permission], entity.targetClass, entity.targetId, true);
     }
     async assignDirectAllPermissions(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
+        return this.permissionService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
     }
     allow(permission, target) {
         return this.allowAll([permission], target);
@@ -156,13 +162,13 @@ export class ModelHasRolePermissions {
     }
     async revokeAllPermissions(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionsService.revokeAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        return this.permissionService.revokeAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async flushPermissions() {
-        return this.permissionsService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        return this.permissionService.flush(this.map.getAlias(this.model), this.model.getModelId());
     }
     async flush() {
-        await this.permissionsService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        await this.permissionService.flush(this.map.getAlias(this.model), this.model.getModelId());
         await this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
         return true;
     }
@@ -171,11 +177,11 @@ export class ModelHasRolePermissions {
     }
     async forbidAll(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionsService.forbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        return this.permissionService.forbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async unforbidAll(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionsService.unforbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        return this.permissionService.unforbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
     }
     async unforbid(permission, target) {
         return this.unforbidAll([permission], target);

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

@@ -1,7 +1,8 @@
 import BaseService from './base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ModelIdType, MorphInterface } from '../types.js';
+import { ModelIdType, MorphInterface, OptionsInterface } from '../types.js';
 export default class ModelService extends BaseService {
+    protected options: OptionsInterface;
     private modelPermissionClassName;
     private modelRoleClassName;
     private map;
@@ -9,7 +10,7 @@ export default class ModelService extends BaseService {
     private readonly modelPermissionTable;
     private modelRoleQuery;
     private readonly modelRoleTable;
-    constructor(modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
+    constructor(options: OptionsInterface, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
     all(roleId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     allFor(modelType: string, roleId: number): Promise<any>;
     allByPermission(permissionId: ModelIdType): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;

package/build/src/services/model_service.js

@@ -1,32 +1,23 @@
 import BaseService from './base_service.js';
 import { getModelPermissionModelQuery, getModelRoleModelQuery } from './query_helper.js';
 export default class ModelService extends BaseService {
+    options;
     modelPermissionClassName;
     modelRoleClassName;
     map;
-    // private permissionQuery
-    // private readonly permissionTable
-    // private roleQuery
-    // private readonly roleTable
     modelPermissionQuery;
     modelPermissionTable;
     modelRoleQuery;
     modelRoleTable;
-    constructor(
-    // private roleClassName: typeof BaseModel,
-    // private permissionClassName: typeof BaseModel,
-    modelPermissionClassName, modelRoleClassName, map) {
-        super();
+    constructor(options, modelPermissionClassName, modelRoleClassName, map) {
+        super(options);
+        this.options = options;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
         this.map = map;
-        // this.permissionQuery = getPermissionModelQuery(this.permissionClassName)
-        // this.permissionTable = this.permissionClassName.table
-        // this.roleQuery = getRoleModelQuery(this.roleClassName)
-        // this.roleTable = this.roleClassName.table
-        this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName);
+        this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName, this.getQueryOptions());
         this.modelPermissionTable = this.modelPermissionClassName.table;
-        this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName);
+        this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName, this.getQueryOptions());
         this.modelRoleTable = this.modelRoleClassName.table;
     }
     all(roleId) {

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

@@ -1,12 +1,14 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { PermissionInterface, PermissionModel, ScopeInterface } from '../../types.js';
-export default class EmptyPermission {
-    private permissionClassName;
-    private scope;
+import { MorphInterface, OptionsInterface, PermissionInterface, PermissionModel } from '../../types.js';
+import BaseAdapter from '../base_adapter.js';
+import ModelManager from '../../model_manager.js';
+export default class EmptyPermission extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
     private permissionQuery;
-    constructor(permissionClassName: typeof BaseModel, scope: ScopeInterface);
-    on(scope: string): this;
-    getScope(): string;
+    permissionClassName: typeof BaseModel;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface);
     delete(permission: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
     create(values: Partial<PermissionInterface>): Promise<PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;

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

@@ -1,20 +1,19 @@
 import { getPermissionModelQuery } from '../query_helper.js';
-export default class EmptyPermission {
-    permissionClassName;
-    scope;
+import BaseAdapter from '../base_adapter.js';
+export default class EmptyPermission extends BaseAdapter {
+    manager;
+    map;
+    options;
     permissionQuery;
-    constructor(permissionClassName, scope) {
-        this.permissionClassName = permissionClassName;
-        this.scope = scope;
+    permissionClassName;
+    constructor(manager, map, options) {
+        super(manager, map, options);
+        this.manager = manager;
+        this.map = map;
+        this.options = options;
+        this.permissionClassName = manager.getModel('permission');
         this.permissionQuery = getPermissionModelQuery(this.permissionClassName);
     }
-    on(scope) {
-        this.scope.set(scope);
-        return this;
-    }
-    getScope() {
-        return this.scope.get();
-    }
     delete(permission) {
         return this.permissionQuery.where('slug', permission).delete();
     }

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

@@ -1,24 +1,27 @@
-import { AclModel, MorphInterface, PermissionInterface, ScopeInterface } from '../../types.js';
+import { AclModel, MorphInterface, OptionsInterface, PermissionInterface } from '../../types.js';
 import ModelService from '../model_service.js';
-import RolesService from '../roles/roles_service.js';
-import PermissionsService from './permissions_service.js';
+import RoleService from '../roles/roles_service.js';
+import PermissionService from './permissions_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
-export default class PermissionHasModelRoles {
+import BaseAdapter from '../base_adapter.js';
+import ModelManager from '../../model_manager.js';
+export default class PermissionHasModelRoles extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
     private permission;
-    private roleService;
-    private permissionService;
-    private modelService;
-    private modelPermissionClassName;
-    private roleClassName;
-    private map;
-    private scope;
     private modelPermissionQuery;
+    protected modelPermissionClassName: typeof BaseModel;
+    protected roleClassName: typeof BaseModel;
+    protected roleService: RoleService;
+    protected permissionService: PermissionService;
+    protected modelService: ModelService;
     private roleQuery;
     private readonly roleTable;
-    constructor(permission: PermissionInterface, roleService: RolesService, permissionService: PermissionsService, modelService: ModelService, modelPermissionClassName: typeof BaseModel, roleClassName: typeof BaseModel, map: MorphInterface, scope: ScopeInterface);
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, permission: PermissionInterface);
     models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     on(scope: string): this;
-    getScope(): string;
+    getScope(): any;
     modelsFor(modelType: string): Promise<any>;
     roles(): Promise<import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     belongsToRole(role: string | number): Promise<boolean>;

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

@@ -1,31 +1,41 @@
 import { destructTarget } from '../helper.js';
+import ModelService from '../model_service.js';
+import PermissionService from './permissions_service.js';
 import { getModelPermissionModelQuery, getRoleModelQuery } from '../query_helper.js';
-export default class PermissionHasModelRoles {
+import BaseAdapter from '../base_adapter.js';
+import RolesService from '../roles/roles_service.js';
+export default class PermissionHasModelRoles extends BaseAdapter {
+    manager;
+    map;
+    options;
     permission;
+    modelPermissionQuery;
+    modelPermissionClassName;
+    roleClassName;
     roleService;
     permissionService;
     modelService;
-    modelPermissionClassName;
-    roleClassName;
-    map;
-    scope;
-    modelPermissionQuery;
     // private readonly modelPermissionTable
     roleQuery;
     roleTable;
-    constructor(permission, roleService, permissionService, modelService, modelPermissionClassName, roleClassName, map, scope) {
-        this.permission = permission;
-        this.roleService = roleService;
-        this.permissionService = permissionService;
-        this.modelService = modelService;
-        this.modelPermissionClassName = modelPermissionClassName;
-        this.roleClassName = roleClassName;
+    constructor(manager, map, options, permission) {
+        super(manager, map, options);
+        this.manager = manager;
         this.map = map;
-        this.scope = scope;
+        this.options = options;
+        this.permission = permission;
+        this.modelPermissionClassName = manager.getModel('modelPermission');
+        this.roleClassName = manager.getModel('role');
         this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName);
         // this.modelPermissionTable = this.modelPermissionClassName.table
         this.roleQuery = getRoleModelQuery(this.roleClassName);
         this.roleTable = this.roleClassName.table;
+        const role = manager.getModel('role');
+        const modelPermission = manager.getModel('modelPermission');
+        const modelRole = manager.getModel('modelRole');
+        this.roleService = new RolesService(this.options, role, modelPermission, modelRole, map);
+        this.permissionService = new PermissionService(this.options, manager.getModel('permission'), role, modelPermission, modelRole, map);
+        this.modelService = new ModelService(this.options, modelPermission, modelRole, map);
     }
     models() {
         return this.modelService.allByPermission(this.permission.getModelId());

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

@@ -1,20 +1,20 @@
 import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { ModelIdType, ModelPermissionsQuery, MorphInterface, PermissionModel, ScopeInterface } from '../../types.js';
+import { ModelIdType, ModelPermissionsQuery, MorphInterface, OptionsInterface, PermissionModel } from '../../types.js';
 import BaseService from '../base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
 export default class PermissionsService extends BaseService {
-    private permissionClassName;
-    private roleClassName;
-    private modelPermissionClassName;
-    private modelRoleClassName;
-    private map;
-    private scope;
+    protected options: OptionsInterface;
+    protected permissionClassName: typeof BaseModel;
+    protected roleClassName: typeof BaseModel;
+    protected modelPermissionClassName: typeof BaseModel;
+    protected modelRoleClassName: typeof BaseModel;
+    protected map: MorphInterface;
     private readonly permissionTable;
-    private modelPermissionQuery;
     private readonly modelPermissionTable;
     private readonly modelRoleTable;
-    constructor(permissionClassName: typeof BaseModel, roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface, scope: ScopeInterface);
+    constructor(options: OptionsInterface, permissionClassName: typeof BaseModel, roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
     private get permissionQuery();
+    private get modelPermissionQuery();
     /**
      * return all permissions, including forbidden
      */

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

@@ -1,42 +1,35 @@
 import BaseService from '../base_service.js';
 import { getModelPermissionModelQuery, getPermissionModelQuery } from '../query_helper.js';
 export default class PermissionsService extends BaseService {
+    options;
     permissionClassName;
     roleClassName;
     modelPermissionClassName;
     modelRoleClassName;
     map;
-    scope;
-    // private permissionQuery
     permissionTable;
-    // private roleQuery
-    // private readonly roleTable
-    modelPermissionQuery;
     modelPermissionTable;
-    // private modelRoleQuery
     modelRoleTable;
-    constructor(permissionClassName, roleClassName, modelPermissionClassName, modelRoleClassName, map, scope) {
-        super();
+    constructor(options, permissionClassName, roleClassName, modelPermissionClassName, modelRoleClassName, map) {
+        super(options);
+        this.options = options;
         this.permissionClassName = permissionClassName;
         this.roleClassName = roleClassName;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
         this.map = map;
-        this.scope = scope;
-        // this.permissionQuery = getPermissionModelQuery(this.permissionClassName)
         this.permissionTable = this.permissionClassName.table;
-        // this.roleQuery = getRoleModelQuery(this.roleClassName)
-        // this.roleTable = this.roleClassName.table
-        this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName);
         this.modelPermissionTable = this.modelPermissionClassName.table;
-        // this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName)
         this.modelRoleTable = this.modelRoleClassName.table;
     }
     get permissionQuery() {
-        const q = getPermissionModelQuery(this.permissionClassName);
+        const q = getPermissionModelQuery(this.permissionClassName, this.getQueryOptions());
         this.applyScopes(q);
         return q;
     }
+    get modelPermissionQuery() {
+        return getModelPermissionModelQuery(this.modelPermissionClassName, this.getQueryOptions());
+    }
     /**
      * return all permissions, including forbidden
      */
@@ -295,7 +288,7 @@ export default class PermissionsService extends BaseService {
                     entityType: entityType || '*',
                     entityId,
                     allowed,
-                    scope: this.scope.get(),
+                    scope: this.scope,
                 });
             }
             else {
@@ -303,7 +296,7 @@ export default class PermissionsService extends BaseService {
             }
         }
         if (createManyData.length) {
-            const newPermissions = (await this.permissionClassName.createMany(createManyData));
+            const newPermissions = (await this.permissionClassName.createMany(createManyData, this.getQueryOptions()));
             newPermissions.map((i) => permissionIds.push(i.id));
         }
         // first check if there are assigned or not
@@ -321,7 +314,7 @@ export default class PermissionsService extends BaseService {
             modelId: modelId,
             permissionId: i,
         }));
-        return this.modelPermissionClassName.createMany(modelPermissionMany);
+        return this.modelPermissionClassName.createMany(modelPermissionMany, this.getQueryOptions());
     }
     revokeAll(modelType, modelId, permissions, entityType, entityId) {
         const q = this.modelPermissionQuery
@@ -513,9 +506,9 @@ export default class PermissionsService extends BaseService {
         }
     }
     applyScopes(q) {
-        q.where(this.permissionTable + '.scope', this.scope.get());
+        q.where(this.permissionTable + '.scope', this.scope);
     }
     applyModelPermissionScopes(q, table) {
-        q.where(table + '.scope', this.scope.get());
+        q.where(table + '.scope', this.scope);
     }
 }

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

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

package/build/src/services/query_helper.js

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

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

@@ -1,12 +1,14 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { RoleInterface, RoleModel, ScopeInterface } from '../../types.js';
-export default class EmptyRoles {
-    private roleClassName;
-    private scope;
+import { MorphInterface, OptionsInterface, RoleInterface, RoleModel } from '../../types.js';
+import BaseAdapter from '../base_adapter.js';
+import ModelManager from '../../model_manager.js';
+export default class EmptyRoles extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
     private roleQuery;
-    constructor(roleClassName: typeof BaseModel, scope: ScopeInterface);
-    on(scope: string): this;
-    getScope(): string;
+    protected roleClassName: typeof BaseModel;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface);
     delete(role: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
     create(values: Partial<RoleInterface>): Promise<RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;

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

@@ -1,20 +1,19 @@
 import { getRoleModelQuery } from '../query_helper.js';
-export default class EmptyRoles {
-    roleClassName;
-    scope;
+import BaseAdapter from '../base_adapter.js';
+export default class EmptyRoles extends BaseAdapter {
+    manager;
+    map;
+    options;
     roleQuery;
-    constructor(roleClassName, scope) {
-        this.roleClassName = roleClassName;
-        this.scope = scope;
+    roleClassName;
+    constructor(manager, map, options) {
+        super(manager, map, options);
+        this.manager = manager;
+        this.map = map;
+        this.options = options;
+        this.roleClassName = manager.getModel('role');
         this.roleQuery = getRoleModelQuery(this.roleClassName);
     }
-    on(scope) {
-        this.scope.set(scope);
-        return this;
-    }
-    getScope() {
-        return this.scope.get();
-    }
     delete(role) {
         return this.roleQuery.where('slug', role).delete();
     }

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

@@ -1,15 +1,16 @@
 import ModelService from '../model_service.js';
-import PermissionsService from '../permissions/permissions_service.js';
-import { AclModel, MorphInterface, RoleInterface, ScopeInterface } from '../../types.js';
-export declare class RoleHasModelPermissions {
+import PermissionService from '../permissions/permissions_service.js';
+import { AclModel, MorphInterface, OptionsInterface, RoleInterface } from '../../types.js';
+import BaseAdapter from '../base_adapter.js';
+import ModelManager from '../../model_manager.js';
+export declare class RoleHasModelPermissions extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
     private role;
-    private permissionService;
-    private modelService;
-    private map;
-    private scope;
-    constructor(role: RoleInterface, permissionService: PermissionsService, modelService: ModelService, map: MorphInterface, scope: ScopeInterface);
-    on(scope: string): this;
-    getScope(): string;
+    protected modelService: ModelService;
+    protected permissionService: PermissionService;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, role: RoleInterface);
     models(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     modelsFor(modelType: string): Promise<any>;
     permissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;

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

@@ -1,23 +1,26 @@
 import { destructTarget } from '../helper.js';
-export class RoleHasModelPermissions {
+import ModelService from '../model_service.js';
+import PermissionService from '../permissions/permissions_service.js';
+import BaseAdapter from '../base_adapter.js';
+export class RoleHasModelPermissions extends BaseAdapter {
+    manager;
+    map;
+    options;
     role;
-    permissionService;
     modelService;
-    map;
-    scope;
-    constructor(role, permissionService, modelService, map, scope) {
-        this.role = role;
-        this.permissionService = permissionService;
-        this.modelService = modelService;
+    permissionService;
+    constructor(manager, map, options, role) {
+        super(manager, map, options);
+        this.manager = manager;
         this.map = map;
-        this.scope = scope;
-    }
-    on(scope) {
-        this.scope.set(scope);
-        return this;
-    }
-    getScope() {
-        return this.scope.get();
+        this.options = options;
+        this.role = role;
+        const roleClass = manager.getModel('role');
+        const modelPermission = manager.getModel('modelPermission');
+        const modelRole = manager.getModel('modelRole');
+        const permission = manager.getModel('permission');
+        this.modelService = new ModelService(this.options, modelPermission, modelRole, map);
+        this.permissionService = new PermissionService(this.options, permission, roleClass, modelPermission, modelRole, map);
     }
     models() {
         return this.modelService.all(+this.role.getModelId());

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

@@ -1,21 +1,20 @@
-import { AclModel, ModelIdType, MorphInterface, ScopeInterface } from '../../types.js';
+import { AclModel, ModelIdType, MorphInterface, OptionsInterface } from '../../types.js';
 import BaseService from '../base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
 import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
 export default class RolesService extends BaseService {
-    private roleClassName;
-    private modelPermissionClassName;
-    private modelRoleClassName;
-    private map;
-    private scope;
-    private roleQuery;
+    protected options: OptionsInterface;
+    protected roleClassName: typeof BaseModel;
+    protected modelPermissionClassName: typeof BaseModel;
+    protected modelRoleClassName: typeof BaseModel;
+    protected map: MorphInterface;
     private readonly roleTable;
     private readonly modelPermissionTable;
-    private modelRoleQuery;
     private readonly modelRoleTable;
-    private currentScope;
-    constructor(roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface, scope: ScopeInterface);
+    constructor(options: OptionsInterface, roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
     private modelRolesQuery;
+    private get roleQuery();
+    private get modelRoleQuery();
     all(modelType: string, modelId: ModelIdType): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     has(modelType: string, modelId: ModelIdType, role: string): Promise<boolean>;
     hasAll(modelType: string, modelId: ModelIdType, roles: string[]): Promise<boolean>;

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

@@ -5,38 +5,26 @@ getModelRoleModelQuery,
 // getPermissionModelQuery,
 getRoleModelQuery, } from '../query_helper.js';
 export default class RolesService extends BaseService {
+    options;
     roleClassName;
     modelPermissionClassName;
     modelRoleClassName;
     map;
-    scope;
-    // private permissionQuery
-    // private readonly permissionTable
-    roleQuery;
     roleTable;
     // private modelPermissionQuery
     modelPermissionTable;
-    modelRoleQuery;
     modelRoleTable;
-    currentScope;
-    constructor(roleClassName, 
+    constructor(options, roleClassName, 
     // private permissionClassName: typeof BaseModel,
-    modelPermissionClassName, modelRoleClassName, map, scope) {
-        super();
+    modelPermissionClassName, modelRoleClassName, map) {
+        super(options);
+        this.options = options;
         this.roleClassName = roleClassName;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
         this.map = map;
-        this.scope = scope;
-        // this.permissionQuery = getPermissionModelQuery(this.permissionClassName)
-        // this.permissionTable = this.permissionClassName.table
-        this.currentScope = this.scope.get();
-        this.roleQuery = getRoleModelQuery(this.roleClassName);
         this.roleTable = this.roleClassName.table;
-        this.applyScopes(this.roleQuery, this.currentScope);
-        // this.modelPermissionQuery = getModelPermissionModelQuery(this.modelPermissionClassName)
         this.modelPermissionTable = this.modelPermissionClassName.table;
-        this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName);
         this.modelRoleTable = this.modelRoleClassName.table;
     }
     modelRolesQuery(modelType, modelId) {
@@ -45,6 +33,14 @@ export default class RolesService extends BaseService {
             .where('mr.model_type', modelType)
             .where('mr.model_id', modelId);
     }
+    get roleQuery() {
+        const q = getRoleModelQuery(this.roleClassName, this.getQueryOptions());
+        this.applyScopes(q, this.scope);
+        return q;
+    }
+    get modelRoleQuery() {
+        return getModelRoleModelQuery(this.modelRoleClassName, this.getQueryOptions());
+    }
     all(modelType, modelId) {
         return this.modelRolesQuery(modelType, modelId)
             .distinct(this.roleTable + '.id')
@@ -63,10 +59,6 @@ export default class RolesService extends BaseService {
             rolesQuery.whereIn(this.roleTable + '.id', ids);
         }
         const r = await rolesQuery.count('* as total');
-        // const q = await rolesQuery.toQuery()
-        // const all = await rolesQuery
-        // console.log(q)
-        // console.log(all)
         // @ts-ignore
         return +r[0].$extras.total === roles.length;
     }
@@ -111,7 +103,7 @@ export default class RolesService extends BaseService {
                 roleId: id,
             });
         }
-        await this.modelRoleClassName.createMany(data);
+        await this.modelRoleClassName.createMany(data, this.getQueryOptions());
         return true;
     }
     async revoke(role, model) {
@@ -131,7 +123,7 @@ export default class RolesService extends BaseService {
                 query.orWhereIn('r.id', ids);
             }
         });
-        this.applyModelRoleScopes(q, 'r', this.currentScope);
+        this.applyModelRoleScopes(q, 'r', this.scope);
         await q.delete();
         return true;
     }

package/build/src/types.d.ts

@@ -1,4 +1,4 @@
-import { LucidModel } from '@adonisjs/lucid/types/model';
+import { LucidModel, ModelAdapterOptions } from '@adonisjs/lucid/types/model';
 import { DateTime } from 'luxon';
 import { BaseModel } from '@adonisjs/lucid/orm';
 import { Scope } from './scope.js';
@@ -78,6 +78,8 @@ export interface MorphInterface {
 export interface ModelManagerInterface {
     [key: string]: any;
 }
+export interface OptionsInterface extends ModelManagerInterface {
+}
 export interface Permissions {
     tables: Object;
     morphMaps: Object;
@@ -94,6 +96,7 @@ export interface ModelManagerBindings {
     permission: typeof BaseModel;
     modelRole: typeof BaseModel;
     modelPermission: typeof BaseModel;
+    queryClient: ModelAdapterOptions;
 }
 export interface AclMiddlewareOptions {
     role: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holoyan/adonisjs-permissions",
   "description": "Adonisjs roles and permissions system",
-  "version": "0.7.15",
+  "version": "0.8.17",
   "engines": {
     "node": ">=18.16.0"
   },