@holoyan/adonisjs-permissions 0.5.0 → 0.6.4

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

@@ -6,7 +6,8 @@ export default class PermissionsService extends BaseService {
     modelPermissionClassName;
     modelRoleClassName;
     map;
-    permissionQuery;
+    scope;
+    // private permissionQuery
     permissionTable;
     // private roleQuery
     // private readonly roleTable
@@ -14,14 +15,15 @@ export default class PermissionsService extends BaseService {
     modelPermissionTable;
     // private modelRoleQuery
     modelRoleTable;
-    constructor(permissionClassName, roleClassName, modelPermissionClassName, modelRoleClassName, map) {
+    constructor(permissionClassName, roleClassName, modelPermissionClassName, modelRoleClassName, map, scope) {
         super();
         this.permissionClassName = permissionClassName;
         this.roleClassName = roleClassName;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
         this.map = map;
-        this.permissionQuery = getPermissionModelQuery(this.permissionClassName);
+        this.scope = scope;
+        // this.permissionQuery = getPermissionModelQuery(this.permissionClassName)
         this.permissionTable = this.permissionClassName.table;
         // this.roleQuery = getRoleModelQuery(this.roleClassName)
         // this.roleTable = this.roleClassName.table
@@ -30,6 +32,11 @@ export default class PermissionsService extends BaseService {
         // this.modelRoleQuery = getModelRoleModelQuery(this.modelRoleClassName)
         this.modelRoleTable = this.modelRoleClassName.table;
     }
+    get permissionQuery() {
+        const q = getPermissionModelQuery(this.permissionClassName);
+        this.applyScopes(q);
+        return q;
+    }
     /**
      * return all permissions, including forbidden
      */
@@ -85,6 +92,16 @@ export default class PermissionsService extends BaseService {
             .distinct(this.permissionTable + '.id')
             .select(this.permissionTable + '.*');
     }
+    async throughRoles(modelType, modelId, includeForbiddings = false) {
+        return this.modelPermissionQueryBuilder({
+            modelType,
+            modelId,
+            includeForbiddings,
+            throughRoles: true,
+        })
+            .distinct(this.permissionTable + '.id')
+            .select(this.permissionTable + '.*');
+    }
     directGlobal(modelType, modelId, includeForbiddings = false) {
         return this.modelPermissionQueryBuilder({
             modelType,
@@ -106,7 +123,7 @@ export default class PermissionsService extends BaseService {
             directPermissions: true,
             includeForbiddings,
         })
-            .whereNotNull(this.permissionTable + '.entity_id')
+            .where(this.permissionTable + '.entity_type', '!=', '*')
             .distinct(this.permissionTable + '.id')
             .select(this.permissionTable + '.*');
     }
@@ -288,6 +305,16 @@ export default class PermissionsService extends BaseService {
             const newPermissions = (await this.permissionClassName.createMany(createManyData));
             newPermissions.map((i) => permissionIds.push(i.id));
         }
+        // first check if there are assigned or not
+        const alreadyAssigned = await this.modelPermissionQuery
+            .whereIn('id', permissionIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const alreadyAssignedIds = alreadyAssigned.map((item) => item.id);
+        permissionIds = permissionIds.filter((item) => {
+            return !alreadyAssignedIds.includes(item);
+        });
         let modelPermissionMany = permissionIds.map((i) => ({
             modelType: modelType,
             modelId: modelId,
@@ -302,6 +329,7 @@ export default class PermissionsService extends BaseService {
             .where('p.allowed', true)
             .where(this.modelPermissionTable + '.model_type', modelType)
             .where(this.modelPermissionTable + '.model_id', modelId);
+        this.applyModelPermissionScopes(q, 'p');
         if (entityType) {
             q.where('p.entity_type', entityType);
             if (entityId) {
@@ -342,13 +370,13 @@ export default class PermissionsService extends BaseService {
      * to remove forbidden permission on model
      */
     async unforbidAll(modelType, modelId, permissionsSlug, entityType, entityId) {
-        // todo replace using reverseModelPermissionQuery() method
         const q = this.modelPermissionQuery
             .leftJoin(this.permissionTable + ' as p', 'p.id', '=', this.modelPermissionTable + '.permission_id')
             .where('model_type', modelType)
             .where('model_id', modelId)
             .whereIn('p.slug', permissionsSlug)
             .where('p.allowed', false);
+        this.applyModelPermissionScopes(q, 'p');
         if (entityType) {
             q.where('p.entity_type', entityType);
             if (entityId) {
@@ -374,15 +402,21 @@ export default class PermissionsService extends BaseService {
             else {
                 q.leftJoin(this.modelRoleTable + ' as mr', (joinQuery) => {
                     joinQuery.onVal('mr.model_type', modelType).onVal('mr.model_id', modelId);
-                }).where((subQuery) => {
-                    subQuery
-                        .where((query) => {
-                        query.where('mp.model_type', modelType).where('mp.model_id', modelId);
-                    })
-                        .orWhere((query) => {
-                        query.whereRaw('mr.role_id=mp.model_id').where('mp.model_type', 'roles');
-                    });
                 });
+                if (conditions.throughRoles) {
+                    q.whereRaw('mr.role_id=mp.model_id').where('mp.model_type', 'roles');
+                }
+                else {
+                    q.where((subQuery) => {
+                        subQuery
+                            .where((query) => {
+                            query.where('mp.model_type', modelType).where('mp.model_id', modelId);
+                        })
+                            .orWhere((query) => {
+                            query.whereRaw('mr.role_id=mp.model_id').where('mp.model_type', 'roles');
+                        });
+                    });
+                }
             }
         }
         if (!includeForbiddings) {
@@ -392,6 +426,7 @@ export default class PermissionsService extends BaseService {
                     .leftJoin(this.modelPermissionTable + ' as mp2', 'mp2.permission_id', '=', 'p2.id')
                     .where('p2.allowed', false)
                     .whereRaw('p2.slug=' + this.permissionTable + '.slug')
+                    .whereRaw('p2.scope=' + this.permissionTable + '.scope')
                     .select('p2.slug')
                     .groupBy('p2.slug');
                 if (conditions.entity) {
@@ -404,6 +439,10 @@ export default class PermissionsService extends BaseService {
         }
         return q;
     }
+    /**
+     * @deprecated
+     * @param conditions
+     */
     reverseModelPermissionQuery(conditions) {
         const { modelId, modelType, permissionSlugs, directPermissions } = conditions;
         const q = this.modelPermissionQuery.leftJoin(this.permissionTable + ' as p', 'p.id', '=', this.modelPermissionTable + '.permission_id');
@@ -468,4 +507,10 @@ export default class PermissionsService extends BaseService {
             q.where(table + '.entity_type', '*').whereNull(table + '.entity_id');
         }
     }
+    applyScopes(q) {
+        q.where(this.permissionTable + '.scope', this.scope.get());
+    }
+    applyModelPermissionScopes(q, table) {
+        q.where(table + '.scope', this.scope.get());
+    }
 }

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

@@ -1,7 +1,7 @@
 import { LucidModel, 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>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, PermissionModel<T>>;
-export declare function getRoleModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, RoleModel<T>>;
-export declare function getModelPermissionModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, ModelPermissionModel<T>>;
-export declare function getModelRoleModelQuery<T extends LucidModel>(permissionClassName: typeof BaseModel): ModelQueryBuilderContract<T, ModelRoleModel<T>>;
+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>>;

package/build/src/services/query_helper.js

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

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

@@ -1,8 +1,12 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
+import { ScopeInterface } from '../../types.js';
 export default class EmptyRoles {
     private roleClassName;
+    private scope;
     private roleQuery;
-    constructor(roleClassName: typeof BaseModel);
+    constructor(roleClassName: typeof BaseModel, scope: ScopeInterface);
+    on(scope: number): this;
+    getScope(): number;
     delete(role: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
     query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
 }

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

@@ -1,11 +1,20 @@
 import { getRoleModelQuery } from '../query_helper.js';
 export default class EmptyRoles {
     roleClassName;
+    scope;
     roleQuery;
-    constructor(roleClassName) {
+    constructor(roleClassName, scope) {
         this.roleClassName = roleClassName;
+        this.scope = scope;
         this.roleQuery = getRoleModelQuery(this.roleClassName);
     }
+    on(scope) {
+        this.scope.set(scope);
+        return this;
+    }
+    getScope() {
+        return this.scope.get();
+    }
     delete(role) {
         // get all permissions by slug
         // if there is permission with allowed false then check if it has `links`

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

@@ -1,18 +1,17 @@
 import ModelService from '../model_service.js';
 import PermissionsService from '../permissions/permissions_service.js';
-import { AclModel, MorphInterface, PermissionInterface, RoleInterface } from '../../types.js';
+import { AclModel, MorphInterface, PermissionInterface, RoleInterface, ScopeInterface } from '../../types.js';
 export declare class RoleHasModelPermissions {
     private role;
     private permissionService;
     private modelService;
     private map;
-    constructor(role: RoleInterface, permissionService: PermissionsService, modelService: ModelService, map: MorphInterface);
+    private scope;
+    constructor(role: RoleInterface, permissionService: PermissionsService, modelService: ModelService, map: MorphInterface, scope: ScopeInterface);
+    on(scope: number): this;
+    getScope(): number;
     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>;
-    /**
-     * todo
-     * @param model
-     */
     permissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     globalPermissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     onResourcePermissions(): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
@@ -52,9 +51,11 @@ export declare class RoleHasModelPermissions {
     canAny(permissions: (string | PermissionInterface)[]): Promise<boolean>;
     forbidden(permission: string | PermissionInterface, target?: AclModel | Function): Promise<boolean>;
     assign(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[]>;
     give(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     giveAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     assingAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+    allowAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     revokePermission(permission: string): Promise<any[]>;
     revoke(permission: string): Promise<any[]>;
     revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;

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

@@ -4,11 +4,20 @@ export class RoleHasModelPermissions {
     permissionService;
     modelService;
     map;
-    constructor(role, permissionService, modelService, map) {
+    scope;
+    constructor(role, permissionService, modelService, map, scope) {
         this.role = role;
         this.permissionService = permissionService;
         this.modelService = modelService;
         this.map = map;
+        this.scope = scope;
+    }
+    on(scope) {
+        this.scope.set(scope);
+        return this;
+    }
+    getScope() {
+        return this.scope.get();
     }
     models() {
         return this.modelService.all(this.role.getModelId());
@@ -16,11 +25,6 @@ export class RoleHasModelPermissions {
     modelsFor(modelType) {
         return this.modelService.allFor(modelType, this.role.getModelId());
     }
-    /**
-     * todo
-     * @param model
-     */
-    // attachTo(model: LucidModel) {}
     // permissions related BEGIN
     async permissions() {
         // for roles direct and all permissions are same
@@ -100,6 +104,9 @@ export class RoleHasModelPermissions {
     assign(permission, target) {
         return this.give(permission, target);
     }
+    allow(permission, target) {
+        return this.give(permission, target);
+    }
     async give(permission, target) {
         const entity = await destructTarget(this.map, target);
         return this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), [permission], entity.targetClass, entity.targetId, true);
@@ -111,6 +118,9 @@ export class RoleHasModelPermissions {
     assingAll(permissions, target) {
         return this.giveAll(permissions, target);
     }
+    allowAll(permissions, target) {
+        return this.giveAll(permissions, target);
+    }
     async revokePermission(permission) {
         return this.revoke(permission);
     }

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

@@ -1,19 +1,22 @@
-import { AclModel, MorphInterface, RoleInterface } from '../../types.js';
+import { AclModel, MorphInterface, RoleInterface, ScopeInterface } 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;
     private readonly roleTable;
     private readonly modelPermissionTable;
     private modelRoleQuery;
     private readonly modelRoleTable;
-    constructor(roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
+    private currentScope;
+    constructor(roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface, scope: ScopeInterface);
     private modelRolesQuery;
-    all(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    all(modelType: string, modelId: number): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     has(modelType: string, modelId: number, role: string | RoleInterface): Promise<boolean>;
     hasAll(modelType: string, modelId: number, roles: (string | RoleInterface)[]): Promise<boolean>;
     hasAny(modelType: string, modelId: number, roles: (string | RoleInterface)[]): Promise<boolean>;
@@ -22,6 +25,8 @@ export default class RolesService extends BaseService {
     revoke(role: string | number, model: AclModel): Promise<boolean>;
     revokeAll(roles: (string | number)[], model: AclModel): Promise<boolean>;
     private extractRoleModel;
-    roleModelPermissionQuery(modelType: string): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
-    flush(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
+    roleModelPermissionQuery(modelType: string): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    flush(modelType: string, modelId: number): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
+    private applyScopes;
+    private applyModelRoleScopes;
 }

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

@@ -9,6 +9,7 @@ export default class RolesService extends BaseService {
     modelPermissionClassName;
     modelRoleClassName;
     map;
+    scope;
     // private permissionQuery
     // private readonly permissionTable
     roleQuery;
@@ -17,18 +18,22 @@ export default class RolesService extends BaseService {
     modelPermissionTable;
     modelRoleQuery;
     modelRoleTable;
+    currentScope;
     constructor(roleClassName, 
     // private permissionClassName: typeof BaseModel,
-    modelPermissionClassName, modelRoleClassName, map) {
+    modelPermissionClassName, modelRoleClassName, map, scope) {
         super();
         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);
@@ -36,12 +41,14 @@ export default class RolesService extends BaseService {
     }
     modelRolesQuery(modelType, modelId) {
         return this.roleQuery
-            .join(this.modelRoleTable + ' as mr', 'mr.role_id', '=', this.roleTable + '.id')
+            .leftJoin(this.modelRoleTable + ' as mr', 'mr.role_id', '=', this.roleTable + '.id')
             .where('mr.model_type', modelType)
             .where('mr.model_id', modelId);
     }
     all(modelType, modelId) {
-        return this.modelRolesQuery(modelType, modelId).select(this.roleTable + '.*');
+        return this.modelRolesQuery(modelType, modelId)
+            .distinct(this.roleTable + '.id')
+            .select(this.roleTable + '.*');
     }
     has(modelType, modelId, role) {
         return this.hasAll(modelType, modelId, [role]);
@@ -74,29 +81,30 @@ export default class RolesService extends BaseService {
         // @ts-ignore
         return +r[0].$extras.total > 0;
     }
-    async assign(role, modelType, modelId) {
-        const r = await this.extractRoleModel([role]);
-        if (!r.length) {
-            throw new Error('Role  not found');
-        }
-        await this.modelRoleClassName.create({
-            modelType,
-            modelId,
-            roleId: r[0].id,
-        });
-        return true;
+    assign(role, modelType, modelId) {
+        return this.assignAll([role], modelType, modelId);
     }
     async assignAll(roles, modelType, modelId) {
         const rs = await this.extractRoleModel(roles);
         if (!rs.length) {
             throw new Error('One or many roles not found');
         }
+        let roleIds = rs.map((role) => role.id);
+        const modelRoles = await this.modelRoleQuery
+            .whereIn('role_id', roleIds)
+            .where('model_type', modelType)
+            .where('model_id', modelId)
+            .select('id');
+        const modelRoleIds = modelRoles.map((modelRole) => modelRole.id);
+        roleIds = roleIds.filter((roleId) => {
+            return !modelRoleIds.includes(roleId);
+        });
         const data = [];
-        for (const r of rs) {
+        for (const id of roleIds) {
             data.push({
                 modelType,
                 modelId,
-                roleId: r.id,
+                roleId: id,
             });
         }
         await this.modelRoleClassName.createMany(data);
@@ -107,14 +115,15 @@ export default class RolesService extends BaseService {
     }
     async revokeAll(roles, model) {
         const { slugs, ids } = this.formatListStringNumbers(roles);
-        await this.modelRoleQuery
+        const q = this.modelRoleQuery
             .leftJoin(this.roleTable + ' as r', 'r.id', '=', this.modelRoleTable + '.role_id')
             .where('model_type', this.map.getAlias(model))
             .where('model_id', model.getModelId())
             .where((query) => {
             query.whereIn('r.id', ids).orWhereIn('r.slug', slugs);
-        })
-            .delete();
+        });
+        this.applyModelRoleScopes(q, 'r', this.currentScope);
+        await q.delete();
         return true;
     }
     async extractRoleModel(roles) {
@@ -139,4 +148,10 @@ export default class RolesService extends BaseService {
     flush(modelType, modelId) {
         return this.modelRoleQuery.where('model_type', modelType).where('model_id', modelId).delete();
     }
+    applyScopes(q, scope) {
+        q.where(this.roleTable + '.scope', scope);
+    }
+    applyModelRoleScopes(q, table, scope) {
+        q.where(table + '.scope', scope);
+    }
 }

package/build/src/types.d.ts

@@ -1,5 +1,7 @@
 import { LucidModel } from '@adonisjs/lucid/types/model';
 import { DateTime } from 'luxon';
+import { BaseModel } from '@adonisjs/lucid/orm';
+import { Scope } from './scope.js';
 export interface AclModelInterface {
     getModelId(): number;
 }
@@ -60,6 +62,7 @@ export interface ModelPermissionsQuery extends AclModelQuery {
     directPermissions: boolean;
     includeForbiddings: boolean;
     entity: Entity;
+    throughRoles: boolean;
 }
 export interface MorphMapInterface {
     [key: string]: any;
@@ -72,10 +75,28 @@ export interface MorphInterface {
     getAlias(target: any): string;
 }
 export interface ModelManagerInterface {
-    [key: string]: LucidModel;
+    [key: string]: any;
 }
 export interface Permissions {
     tables: Object;
     morphMaps: Object;
 }
+export interface ScopeInterface {
+    set(scope: number): ScopeInterface;
+    get(): number;
+    default(): number;
+}
+export interface ModelManagerBindings {
+    scope: typeof Scope;
+    role: typeof BaseModel;
+    permission: typeof BaseModel;
+    modelRole: typeof BaseModel;
+    modelPermission: typeof BaseModel;
+}
+export interface AclMiddlewareOptions {
+    role: string;
+    permission: string;
+    scope: number;
+    method: string;
+}
 export {};

package/build/stubs/middlewares/acl_middleware.stub

@@ -0,0 +1,26 @@
+{{{
+  exports({ to: app.middlewarePath('', 'acl_middleware.ts') })
+}}}
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
+import { AclManager, Scope } from '@holoyan/adonisjs-permissions'
+
+declare module '@adonisjs/core/http' {
+  export interface HttpContext {
+    acl: AclManager
+  }
+}
+
+export default class UserScopeMiddleware {
+  //@ts-ignore
+  async handle(ctx: HttpContext, next: NextFn) {
+    const scope = new Scope()
+    ctx.acl = new AclManager().scope(scope)
+    /**
+     * Call next method in the pipeline and return its output
+     */
+    const output = await next()
+    return output
+  }
+}
+

package/package.json

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