@holoyan/adonisjs-permissions 0.8.21 → 0.9.0

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

@@ -1,26 +1,35 @@
 import { destructTarget } from '../helper.js';
-import ModelService from '../model_service.js';
+import ModelService from '../models/model_service.js';
 import PermissionService from '../permissions/permissions_service.js';
 import BaseAdapter from '../base_adapter.js';
+import { PermissionsAttachedToRoleEvent, PermissionsDetachedFromRoleEvent, PermissionsFlushedFromRoleEvent, } from '../../events/index.js';
 export class RoleHasModelPermissions extends BaseAdapter {
     manager;
     map;
     options;
+    scope;
     role;
-    modelService;
-    permissionService;
-    constructor(manager, map, options, role) {
-        super(manager, map, options);
+    emitter;
+    constructor(manager, map, options, scope, role, emitter) {
+        super(manager, map, options, scope, emitter);
         this.manager = manager;
         this.map = map;
         this.options = options;
+        this.scope = scope;
         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);
+        this.emitter = emitter;
+    }
+    get modelService() {
+        const modelPermission = this.manager.getModel('modelPermission');
+        const modelRole = this.manager.getModel('modelRole');
+        return new ModelService(this.options, this.scope, modelPermission, modelRole, this.map).setQueryOptions(this.queryOptions);
+    }
+    get permissionService() {
+        const roleClass = this.manager.getModel('role');
+        const modelPermission = this.manager.getModel('modelPermission');
+        const modelRole = this.manager.getModel('modelRole');
+        const permission = this.manager.getModel('permission');
+        return new PermissionService(this.options, this.scope, permission, roleClass, modelPermission, modelRole, this.map).setQueryOptions(this.queryOptions);
     }
     models() {
         return this.modelService.all(+this.role.getModelId());
@@ -106,41 +115,100 @@ export class RoleHasModelPermissions extends BaseAdapter {
         const entity = await destructTarget(this.map, target);
         return this.permissionService.forbidden(this.map.getAlias(this.role), this.role.getModelId(), permission, entity.targetClass, entity.targetId);
     }
+    /**
+     * calls giveAll()
+     * @param permission
+     * @param target
+     */
     assign(permission, target) {
-        return this.give(permission, target);
+        return this.giveAll([permission], target);
     }
+    /**
+     * calls giveAll()
+     * @param permission
+     * @param target
+     */
     allow(permission, target) {
-        return this.give(permission, target);
+        return this.giveAll([permission], target);
     }
+    /**
+     * calls giveAll()
+     * @param permission
+     * @param 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);
+        return this.giveAll([permission], target);
     }
+    /**
+     * @param permissions
+     * @param target
+     */
     async giveAll(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId, true);
+        const attached = await this.permissionService.giveAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId, true);
+        if (attached.length > 0) {
+            this.fire(PermissionsAttachedToRoleEvent, attached.map((item) => item.permissionId), this.role.getModelId());
+        }
+        return attached;
     }
+    /**
+     * calls giveAll()
+     * @param permissions
+     * @param target
+     */
     assignAll(permissions, target) {
         return this.giveAll(permissions, target);
     }
+    /**
+     * calls giveAll()
+     * @param permissions
+     * @param target
+     */
     allowAll(permissions, target) {
         return this.giveAll(permissions, target);
     }
+    /**
+     * calls revokeAll()
+     * @param permission
+     */
     async revokePermission(permission) {
-        return this.revoke(permission);
+        return this.revokeAll([permission]);
     }
+    /**
+     * calls revokeAll()
+     * @param permission
+     */
     async revoke(permission) {
         return this.revokeAll([permission]);
     }
     async revokeAll(permissions, target) {
         const entity = await destructTarget(this.map, target);
-        return this.permissionService.revokeAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
+        const revoked = await this.permissionService.revokeAll(this.map.getAlias(this.role), this.role.getModelId(), permissions, entity.targetClass, entity.targetId);
+        if (revoked.length > 0) {
+            this.fire(PermissionsDetachedFromRoleEvent, permissions, this.role.getModelId());
+        }
     }
+    /**
+     * calls revokeAll()
+     * @param permissions
+     */
     async revokeAllPermissions(permissions) {
         return this.revokeAll(permissions);
     }
     async flush() {
-        return this.permissionService.flush(this.map.getAlias(this.role), this.role.getModelId());
+        const flushed = await this.permissionService.flush(this.map.getAlias(this.role), this.role.getModelId());
+        if (flushed.length > 0) {
+            this.fire(PermissionsFlushedFromRoleEvent, this.role.getModelId());
+        }
+    }
+    /**
+     * Sync permissions with the given list
+     * @param permissions - list of permissions
+     * @param target
+     */
+    async sync(permissions, target) {
+        await this.flush();
+        return this.giveAll(permissions, target);
     }
     async forbid(permission, target) {
         const entity = await destructTarget(this.map, target);

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

@@ -2,20 +2,23 @@ import { AclModel, ModelIdType, MorphInterface, OptionsInterface } from '../../t
 import BaseService from '../base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
 import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+import Role from '../../models/role.js';
+import { Scope } from '../../scope.js';
 export default class RolesService extends BaseService {
     protected options: OptionsInterface;
-    protected roleClassName: typeof BaseModel;
+    protected scope: Scope;
+    protected roleClassName: typeof Role;
     protected modelPermissionClassName: typeof BaseModel;
     protected modelRoleClassName: typeof BaseModel;
     protected map: MorphInterface;
     private readonly roleTable;
     private readonly modelPermissionTable;
     private readonly modelRoleTable;
-    constructor(options: OptionsInterface, roleClassName: typeof BaseModel, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
+    constructor(options: OptionsInterface, scope: Scope, roleClassName: typeof Role, 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>>;
+    all(modelType: string, modelId: ModelIdType): ModelQueryBuilderContract<typeof Role, Role>;
     has(modelType: string, modelId: ModelIdType, role: string): Promise<boolean>;
     hasAll(modelType: string, modelId: ModelIdType, roles: string[]): Promise<boolean>;
     hasAny(modelType: string, modelId: ModelIdType, roles: string[]): Promise<boolean>;
@@ -24,8 +27,9 @@ export default class RolesService extends BaseService {
     revoke(role: string, model: AclModel): Promise<boolean>;
     revokeAll(roles: string[], model: AclModel): Promise<boolean>;
     private extractRoleModel;
-    roleModelPermissionQuery(modelType: string): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    roleModelPermissionQuery(modelType: string): ModelQueryBuilderContract<typeof Role, Role>;
     flush(modelType: string, modelId: ModelIdType): ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
     private applyScopes;
     private applyModelRoleScopes;
+    findBySlug(slug: string): Promise<Role | null>;
 }

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

@@ -1,11 +1,8 @@
 import BaseService from '../base_service.js';
-import { 
-// getModelPermissionModelQuery,
-getModelRoleModelQuery, 
-// getPermissionModelQuery,
-getRoleModelQuery, } from '../query_helper.js';
+import { getModelRoleModelQuery } from '../query_helper.js';
 export default class RolesService extends BaseService {
     options;
+    scope;
     roleClassName;
     modelPermissionClassName;
     modelRoleClassName;
@@ -14,11 +11,10 @@ export default class RolesService extends BaseService {
     // private modelPermissionQuery
     modelPermissionTable;
     modelRoleTable;
-    constructor(options, roleClassName, 
-    // private permissionClassName: typeof BaseModel,
-    modelPermissionClassName, modelRoleClassName, map) {
-        super(options);
+    constructor(options, scope, roleClassName, modelPermissionClassName, modelRoleClassName, map) {
+        super(options, scope);
         this.options = options;
+        this.scope = scope;
         this.roleClassName = roleClassName;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
@@ -34,8 +30,8 @@ export default class RolesService extends BaseService {
             .where('mr.model_id', modelId);
     }
     get roleQuery() {
-        const q = getRoleModelQuery(this.roleClassName, this.getQueryOptions());
-        this.applyScopes(q, this.scope);
+        const q = this.roleClassName.query(this.getQueryOptions());
+        this.applyScopes(q, this.scope.get());
         return q;
     }
     get modelRoleQuery() {
@@ -103,8 +99,8 @@ export default class RolesService extends BaseService {
                 roleId: id,
             });
         }
-        await this.modelRoleClassName.createMany(data, this.getQueryOptions());
-        return true;
+        const created = await this.modelRoleClassName.createMany(data, this.getQueryOptions());
+        return created.length === data.length;
     }
     async revoke(role, model) {
         return this.revokeAll([role], model);
@@ -123,9 +119,9 @@ export default class RolesService extends BaseService {
                 query.orWhereIn('r.id', ids);
             }
         });
-        this.applyModelRoleScopes(q, 'r', this.scope);
-        await q.delete();
-        return true;
+        this.applyModelRoleScopes(q, 'r', this.scope.get());
+        const d = await q.delete();
+        return d.length > 0;
     }
     extractRoleModel(roles) {
         return this.roleQuery.whereIn('slug', roles);
@@ -144,4 +140,7 @@ export default class RolesService extends BaseService {
     applyModelRoleScopes(q, table, scope) {
         q.where(table + '.scope', scope);
     }
+    findBySlug(slug) {
+        return this.roleQuery.where('slug', slug).first();
+    }
 }

package/build/src/types.d.ts

@@ -1,7 +1,11 @@
 import { LucidModel, ModelAdapterOptions } from '@adonisjs/lucid/types/model';
 import { DateTime } from 'luxon';
-import { BaseModel } from '@adonisjs/lucid/orm';
 import { Scope } from './scope.js';
+import Permission from './models/permission.js';
+import Role from './models/role.js';
+import ModelPermission from './models/model_permission.js';
+import ModelRole from './models/model_role.js';
+import { BaseEvent } from '@adonisjs/core/events';
 export interface AclModelInterface {
     getModelId(): ModelIdType;
 }
@@ -10,7 +14,7 @@ export interface PermissionInterface extends AclModelInterface {
     slug: string;
     title: string | null;
     entityType: string;
-    entityId: string | null;
+    entityId: ModelIdType | null;
     allowed: boolean;
     scope: string;
     createdAt: DateTime;
@@ -21,7 +25,7 @@ export interface RoleInterface extends AclModelInterface {
     slug: string;
     title: string | null;
     entityType: string;
-    entityId: string | null;
+    entityId: ModelIdType | null;
     scope: string;
     allowed: boolean;
     createdAt: DateTime;
@@ -78,7 +82,14 @@ export interface MorphInterface {
 export interface ModelManagerInterface {
     [key: string]: any;
 }
+interface EventInterface<E extends BaseEvent = BaseEvent> {
+    fire: boolean;
+    except?: E[];
+    only?: E[];
+}
 export interface OptionsInterface extends ModelManagerInterface {
+    queryOptions?: ModelAdapterOptions;
+    events: EventInterface;
 }
 export interface Permissions {
     tables: Object;
@@ -92,10 +103,10 @@ export interface ScopeInterface {
 }
 export interface ModelManagerBindings {
     scope: typeof Scope;
-    role: typeof BaseModel;
-    permission: typeof BaseModel;
-    modelRole: typeof BaseModel;
-    modelPermission: typeof BaseModel;
+    role: typeof Role;
+    permission: typeof Permission;
+    modelRole: typeof ModelRole;
+    modelPermission: typeof ModelPermission;
     queryClient: ModelAdapterOptions;
 }
 export interface AclMiddlewareOptions {

package/build/stubs/middlewares/acl_middleware.stub

@@ -17,6 +17,7 @@ export default class UserScopeMiddleware {
     const scope = new Scope()
     ctx.acl = new AclManager(true).scope(scope)
     /**
+     * Call next method in the pipeline and return its output
      * Call next method in the pipeline and return its output
      */
     const output = await next()

package/build/stubs/migrations/create_db.stub

@@ -8,7 +8,30 @@ import config from '@adonisjs/core/services/config'
 
 export default class extends BaseSchema {
   async up() {
-    this.schema.createTable('permissions', (table) => {
+    this.schema.createTable(
+      config.get('permissions.permissionsConfig.tables.permissions'),
+      (table) => {
+        this.primaryKey(table, 'id')
+
+        table.string('slug')
+        table.string('title').nullable()
+        table.string('entity_type').defaultTo('*')
+        this.modelId(table, 'entity_id').nullable()
+        table.string('scope').defaultTo('default')
+        table.boolean('allowed').defaultTo(true)
+
+        /**
+         * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
+         */
+        table.timestamp('created_at', { useTz: true })
+        table.timestamp('updated_at', { useTz: true })
+
+        table.index(['scope', 'slug'])
+        table.index(['entity_type', 'entity_id'])
+      }
+    )
+
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.roles'), (table) => {
       this.primaryKey(table, 'id')
 
       table.string('slug')
@@ -28,61 +51,53 @@ export default class extends BaseSchema {
       table.index(['entity_type', 'entity_id'])
     })
 
-    this.schema.createTable('roles', (table) => {
-      this.primaryKey(table, 'id')
-
-      table.string('slug')
-      table.string('title').nullable()
-      table.string('entity_type').defaultTo('*')
-      this.modelId(table, 'entity_id').nullable()
-      table.string('scope').defaultTo('default')
-      table.boolean('allowed').defaultTo(true)
-
-      /**
-       * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
-       */
-      table.timestamp('created_at', { useTz: true })
-      table.timestamp('updated_at', { useTz: true })
-
-      table.index(['scope', 'slug'])
-      table.index(['entity_type', 'entity_id'])
-    })
-
-    this.schema.createTable('model_roles', (table) => {
-      table.bigIncrements('id')
-
-      table.string('model_type')
-      this.modelId(table, 'model_id')
-      this.modelId(table, 'role_id')
-
-      /**
-       * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
-       */
-      table.timestamp('created_at', { useTz: true })
-      table.timestamp('updated_at', { useTz: true })
-
-      table.index(['model_type', 'model_id'])
-
-      table.foreign('role_id').references('roles.id').onDelete('CASCADE')
-    })
-
-    this.schema.createTable('model_permissions', (table) => {
-      table.bigIncrements('id')
-
-      table.string('model_type')
-      this.modelId(table, 'model_id')
-      this.modelId(table, 'permission_id')
-
-      /**
-       * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
-       */
-      table.timestamp('created_at', { useTz: true })
-      table.timestamp('updated_at', { useTz: true })
-
-      table.index(['model_type', 'model_id'])
-
-      table.foreign('permission_id').references('permissions.id').onDelete('CASCADE')
-    })
+    this.schema.createTable(
+      config.get('permissions.permissionsConfig.tables.modelRoles'),
+      (table) => {
+        table.bigIncrements('id')
+
+        table.string('model_type')
+        this.modelId(table, 'model_id')
+        this.modelId(table, 'role_id')
+
+        /**
+         * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
+         */
+        table.timestamp('created_at', { useTz: true })
+        table.timestamp('updated_at', { useTz: true })
+
+        table.index(['model_type', 'model_id'])
+
+        table
+          .foreign('role_id')
+          .references(config.get('permissions.permissionsConfig.tables.roles') + '.id')
+          .onDelete('CASCADE')
+      }
+    )
+
+    this.schema.createTable(
+      config.get('permissions.permissionsConfig.tables.modelPermissions'),
+      (table) => {
+        table.bigIncrements('id')
+
+        table.string('model_type')
+        this.modelId(table, 'model_id')
+        this.modelId(table, 'permission_id')
+
+        /**
+         * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
+         */
+        table.timestamp('created_at', { useTz: true })
+        table.timestamp('updated_at', { useTz: true })
+
+        table.index(['model_type', 'model_id'])
+
+        table
+          .foreign('permission_id')
+          .references(config.get('permissions.permissionsConfig.tables.permissions') + '.id')
+          .onDelete('CASCADE')
+      }
+    )
   }
 
   async down() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holoyan/adonisjs-permissions",
   "description": "Adonisjs roles and permissions system",
-  "version": "0.8.21",
+  "version": "0.9.0",
   "engines": {
     "node": ">=18.16.0"
   },
@@ -18,7 +18,8 @@
   "exports": {
     ".": "./build/index.js",
     "./role_permission_provider": "./build/providers/role_permission_provider.js",
-    "./types": "./build/src/types.js"
+    "./types": "./build/src/types.js",
+    "./events": "./build/src/events/index.js"
   },
   "scripts": {
     "clean": "del-cli build",

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

@@ -1,65 +0,0 @@
-import { AclModel, MorphInterface, OptionsInterface } from '../types.js';
-import RolesService from './roles/roles_service.js';
-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;
-    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>;
-    hasAnyRole(...roles: string[]): Promise<boolean>;
-    assignRole(role: string): Promise<boolean>;
-    assign(role: string): Promise<boolean>;
-    assignAllRoles(...roles: string[]): Promise<boolean>;
-    revokeRole(role: string): Promise<boolean>;
-    revokeAllRoles(...roles: string[]): 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>[]>;
-    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>[]>;
-    containsPermission(permission: string): Promise<boolean>;
-    contains(permission: string): Promise<boolean>;
-    containsAllPermissions(permissions: string[]): Promise<boolean>;
-    containsAnyPermission(permissions: string[]): Promise<boolean>;
-    containsDirectPermission(permission: string): Promise<boolean>;
-    containsAllPermissionsDirectly(permissions: string[]): Promise<boolean>;
-    containsAnyPermissionDirectly(permissions: string[]): Promise<boolean>;
-    hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissions(permissions: string[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
-    hasAnyDirectPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
-    hasDirectPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
-    hasAllPermissionsDirect(permissions: string[], target?: AclModel | Function): Promise<boolean>;
-    can(permission: string, target?: AclModel | Function): Promise<boolean>;
-    canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
-    canAny(permissions: string[], 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[]>;
-    allowAll(permission: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
-    revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
-    revoke(permission: string, target?: AclModel | Function): Promise<any[]>;
-    revokeAll(permissions: 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[]>;
-}