@holoyan/adonisjs-permissions 0.8.21 → 0.9.0

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

@@ -0,0 +1,185 @@
+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';
+import { Scope } from '../../scope.js';
+import { Emitter } from '@adonisjs/core/events';
+export declare class ModelHasRolePermissions extends BaseAdapter {
+    protected manager: ModelManager;
+    protected map: MorphInterface;
+    protected options: OptionsInterface;
+    protected scope: Scope;
+    protected model: AclModel;
+    protected emitter: Emitter<any>;
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, scope: Scope, model: AclModel, emitter: Emitter<any>);
+    get roleService(): RolesService;
+    get permissionService(): PermissionService;
+    roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof import("../../models/role.js").default, import("../../models/role.js").default>;
+    hasRole(role: string): Promise<boolean>;
+    hasAllRoles(...roles: string[]): Promise<boolean>;
+    hasAnyRole(...roles: string[]): Promise<boolean>;
+    /**
+     * Assign role to the model
+     * calls assignAllRoles
+     * @param role
+     */
+    assignRole(role: string): Promise<void>;
+    /**
+     * Assign role to the model
+     * calls assignAllRoles
+     * @param role
+     */
+    assign(role: string): Promise<void>;
+    /**
+     * Assign list of roles to the model
+     * @param roles
+     */
+    assignAllRoles(...roles: string[]): Promise<void>;
+    /**
+     * Revoke role from the model
+     * calls revokeAllRoles
+     * @param role
+     */
+    revokeRole(role: string): Promise<boolean>;
+    /**
+     * Revoke role from the model
+     * @param roles
+     */
+    revokeAllRoles(...roles: string[]): Promise<boolean>;
+    flushRoles(): Promise<boolean>;
+    /**
+     * Sync roles with the model  (detach all roles and assign new roles)
+     * @param roles  - array of roles
+     * @param detach - if true, it will detach the existing roles
+     */
+    syncRoles(roles: string[], detach?: boolean): Promise<void>;
+    /**
+     * Sync roles with the model without detaching the existing ones
+     * @param roles
+     */
+    syncRolesWithoutDetaching(roles: string[]): Promise<void>;
+    permissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    /**
+     * returns list of global permissions assigned to the model
+     * @param includeForbiddings
+     */
+    globalPermissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    /**
+     * @param includeForbiddings
+     */
+    onResourcePermissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    directPermissions(includeForbiddings?: boolean): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof import("../../models/permission.js").default, import("../../models/permission.js").default>;
+    /**
+     * Get permission through roles
+     * @param includeForbiddings
+     */
+    rolePermissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    directResourcePermissions(includeForbiddings?: boolean): Promise<import("../../models/permission.js").default[]>;
+    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>;
+    /**
+     * @param permission
+     * @param target
+     */
+    hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
+    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>;
+    /**
+     * calls assignDirectAllPermissions()
+     * @param permission
+     * @param target
+     */
+    assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
+    assignDirectAllPermissions(permissions: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
+    /**
+     * Assign permission to the model
+     * calls assignDirectAllPermissions
+     * @param permission
+     * @param target
+     */
+    allow(permission: string, target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
+    /**
+     * Assign list of permissions to the model
+     * calls assignDirectAllPermissions
+     * @param permission
+     * @param target
+     */
+    allowAll(permission: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
+    /**
+     * Revoke permission from the model
+     * calls revokeAllPermissions
+     * @param permission
+     * @param target
+     */
+    revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
+    /**
+     * Revoke permission from the model
+     * calls revokeAllPermissions
+     * @param permission
+     * @param target
+     */
+    revoke(permission: string, target?: AclModel | Function): Promise<any[]>;
+    /**
+     * Revoke list of permissions from the model
+     * calls revokeAllPermissions
+     * @param permissions
+     * @param target
+     */
+    revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+    /**
+     * @param permissions
+     * @param target
+     */
+    revokeAllPermissions(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+    flushPermissions(): Promise<any[]>;
+    /**
+     * @param permissions
+     * @param target
+     */
+    syncPermissions(permissions: string[], target?: AclModel | Function): Promise<import("../../models/model_permission.js").default[]>;
+    flush(): Promise<boolean>;
+    /**
+     * calls forbidAll
+     * @param permission
+     * @param target
+     */
+    forbid(permission: string, target?: AclModel | Function): Promise<void>;
+    /**
+     * @param permissions
+     * @param target
+     */
+    forbidAll(permissions: string[], target?: AclModel | Function): Promise<void>;
+    /**
+     * @param permissions
+     * @param target
+     */
+    unforbidAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+    /**
+     * @param permission
+     * @param target
+     */
+    unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
+}

package/build/src/services/models/model_has_role_permissions.js

@@ -0,0 +1,346 @@
+import RolesService from '../roles/roles_service.js';
+import { destructTarget, formatList } from '../helper.js';
+import BaseAdapter from '../base_adapter.js';
+import PermissionService from '../permissions/permissions_service.js';
+import { PermissionsAttachedToModelEvent, PermissionsDetachedFromModelEvent, PermissionsFlushedEvent, PermissionsForbadeEvent, PermissionsUnForbadeEvent, } from '../../events/index.js';
+import { RolesAttachedToModel, RolesDetachedFromModelEvent, RolesFlushedFromModelEvent, } from '../../events/index.js';
+export class ModelHasRolePermissions extends BaseAdapter {
+    manager;
+    map;
+    options;
+    scope;
+    model;
+    emitter;
+    constructor(manager, map, options, scope, model, emitter) {
+        super(manager, map, options, scope, emitter);
+        this.manager = manager;
+        this.map = map;
+        this.options = options;
+        this.scope = scope;
+        this.model = model;
+        this.emitter = emitter;
+    }
+    get roleService() {
+        const role = this.manager.getModel('role');
+        const modelPermission = this.manager.getModel('modelPermission');
+        const modelRole = this.manager.getModel('modelRole');
+        return new RolesService(this.options, this.scope, role, modelPermission, modelRole, this.map).setQueryOptions(this.queryOptions);
+    }
+    get permissionService() {
+        const role = this.manager.getModel('role');
+        const modelPermission = this.manager.getModel('modelPermission');
+        const modelRole = this.manager.getModel('modelRole');
+        return new PermissionService(this.options, this.scope, this.manager.getModel('permission'), role, modelPermission, modelRole, this.map).setQueryOptions(this.queryOptions);
+    }
+    // roles related section BEGIN
+    roles() {
+        return this.roleService.all(this.map.getAlias(this.model), this.model.getModelId());
+    }
+    hasRole(role) {
+        return this.roleService.has(this.map.getAlias(this.model), this.model.getModelId(), role);
+    }
+    hasAllRoles(...roles) {
+        return this.roleService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), roles);
+    }
+    hasAnyRole(...roles) {
+        return this.roleService.hasAny(this.map.getAlias(this.model), this.model.getModelId(), roles);
+    }
+    /**
+     * Assign role to the model
+     * calls assignAllRoles
+     * @param role
+     */
+    assignRole(role) {
+        return this.assignAllRoles(role);
+    }
+    /**
+     * Assign role to the model
+     * calls assignAllRoles
+     * @param role
+     */
+    assign(role) {
+        return this.assignAllRoles(role);
+    }
+    /**
+     * Assign list of roles to the model
+     * @param roles
+     */
+    async assignAllRoles(...roles) {
+        const assigned = await this.roleService.assignAll(roles, this.map.getAlias(this.model), this.model.getModelId());
+        if (assigned) {
+            this.fire(RolesAttachedToModel, roles, this.model);
+        }
+    }
+    /**
+     * Revoke role from the model
+     * calls revokeAllRoles
+     * @param role
+     */
+    revokeRole(role) {
+        return this.revokeAllRoles(role);
+    }
+    /**
+     * Revoke role from the model
+     * @param roles
+     */
+    async revokeAllRoles(...roles) {
+        const { slugs } = formatList(roles);
+        const revoked = await this.roleService.revokeAll(slugs, this.model);
+        if (revoked) {
+            this.fire(RolesDetachedFromModelEvent, roles, this.model);
+        }
+        return revoked;
+    }
+    async flushRoles() {
+        const deleted = await this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        if (deleted.length) {
+            this.fire(RolesFlushedFromModelEvent, this.model);
+        }
+        return deleted.length > 0;
+    }
+    /**
+     * Sync roles with the model  (detach all roles and assign new roles)
+     * @param roles  - array of roles
+     * @param detach - if true, it will detach the existing roles
+     */
+    async syncRoles(roles, detach = true) {
+        if (detach) {
+            await this.flushRoles();
+        }
+        return this.assignAllRoles(...roles);
+    }
+    /**
+     * Sync roles with the model without detaching the existing ones
+     * @param roles
+     */
+    syncRolesWithoutDetaching(roles) {
+        return this.syncRoles(roles, false);
+    }
+    // roles related section END
+    // permissions related section BEGIN
+    async permissions(includeForbiddings = false) {
+        return this.permissionService.all(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    /**
+     * returns list of global permissions assigned to the model
+     * @param includeForbiddings
+     */
+    async globalPermissions(includeForbiddings = false) {
+        return this.permissionService.global(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    /**
+     * @param includeForbiddings
+     */
+    async onResourcePermissions(includeForbiddings = false) {
+        return this.permissionService.onResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    directPermissions(includeForbiddings = false) {
+        return this.permissionService.direct(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    /**
+     * Get permission through roles
+     * @param includeForbiddings
+     */
+    rolePermissions(includeForbiddings = false) {
+        return this.permissionService.throughRoles(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    async directGlobalPermissions(includeForbiddings = false) {
+        return this.permissionService.directGlobal(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    async directResourcePermissions(includeForbiddings = false) {
+        return this.permissionService.directResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
+    }
+    async containsPermission(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.permissionService.containsAll(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+        return result;
+    }
+    containsAnyPermission(permissions) {
+        return this.permissionService.containsAny(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+    }
+    containsDirectPermission(permission) {
+        return this.permissionService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), [permission]);
+    }
+    containsAllPermissionsDirectly(permissions) {
+        return this.permissionService.containsAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+    }
+    async containsAnyPermissionDirectly(permissions) {
+        return await this.permissionService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
+    }
+    /**
+     * @param permission
+     * @param target
+     */
+    async hasPermission(permission, target) {
+        return this.hasAnyPermission([permission], target);
+    }
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
+    async hasAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        return await this.permissionService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+    }
+    async hasAnyPermission(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        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.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.permissionService.hasAllDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+    }
+    can(permission, target) {
+        return this.hasPermission(permission, target);
+    }
+    canAll(permissions, target) {
+        return this.hasAllPermissions(permissions, target);
+    }
+    canAny(permissions, target) {
+        return this.hasAnyPermission(permissions, target);
+    }
+    /**
+     * calls assignDirectAllPermissions()
+     * @param permission
+     * @param target
+     */
+    async assignDirectPermission(permission, target) {
+        return this.assignDirectAllPermissions([permission], target);
+    }
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
+    async assignDirectAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const assigned = await this.permissionService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
+        this.fire(PermissionsAttachedToModelEvent, assigned.map((item) => item.permissionId), this.model);
+        return assigned;
+    }
+    /**
+     * Assign permission to the model
+     * calls assignDirectAllPermissions
+     * @param permission
+     * @param target
+     */
+    allow(permission, target) {
+        return this.allowAll([permission], target);
+    }
+    /**
+     * Assign list of permissions to the model
+     * calls assignDirectAllPermissions
+     * @param permission
+     * @param target
+     */
+    allowAll(permission, target) {
+        return this.assignDirectAllPermissions(permission, target);
+    }
+    /**
+     * Revoke permission from the model
+     * calls revokeAllPermissions
+     * @param permission
+     * @param target
+     */
+    async revokePermission(permission, target) {
+        return this.revokeAllPermissions([permission], target);
+    }
+    /**
+     * Revoke permission from the model
+     * calls revokeAllPermissions
+     * @param permission
+     * @param target
+     */
+    async revoke(permission, target) {
+        return this.revokeAllPermissions([permission], target);
+    }
+    /**
+     * Revoke list of permissions from the model
+     * calls revokeAllPermissions
+     * @param permissions
+     * @param target
+     */
+    async revokeAll(permissions, target) {
+        return this.revokeAllPermissions(permissions, target);
+    }
+    /**
+     * @param permissions
+     * @param target
+     */
+    async revokeAllPermissions(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const revoked = this.permissionService.revokeAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        this.fire(PermissionsDetachedFromModelEvent, permissions, this.model);
+        return revoked;
+    }
+    async flushPermissions() {
+        const flushed = await this.permissionService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        if (flushed.length) {
+            this.fire(PermissionsFlushedEvent, this.model);
+        }
+        return flushed;
+    }
+    /**
+     * @param permissions
+     * @param target
+     */
+    async syncPermissions(permissions, target) {
+        await this.flushPermissions();
+        return this.allowAll(permissions, target);
+    }
+    async flush() {
+        await this.flushPermissions();
+        await this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
+        return true;
+    }
+    /**
+     * calls forbidAll
+     * @param permission
+     * @param target
+     */
+    async forbid(permission, target) {
+        return this.forbidAll([permission], target);
+    }
+    /**
+     * @param permissions
+     * @param target
+     */
+    async forbidAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const forbade = await this.permissionService.forbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        this.fire(PermissionsForbadeEvent, forbade.map((item) => item.permissionId), this.model);
+    }
+    /**
+     * @param permissions
+     * @param target
+     */
+    async unforbidAll(permissions, target) {
+        const entity = await destructTarget(this.map, target);
+        const unforbade = await this.permissionService.unforbidAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
+        if (unforbade.length) {
+            this.fire(PermissionsUnForbadeEvent, unforbade.map((item) => item.permissionId), this.model);
+        }
+        return unforbade;
+    }
+    /**
+     * @param permission
+     * @param target
+     */
+    async unforbid(permission, target) {
+        return this.unforbidAll([permission], target);
+    }
+}

package/build/src/services/{model_service.d.ts → models/model_service.d.ts}

@@ -1,8 +1,10 @@
-import BaseService from './base_service.js';
+import BaseService from '../base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ModelIdType, MorphInterface, OptionsInterface } from '../types.js';
+import { ModelIdType, MorphInterface, OptionsInterface } from '../../types.js';
+import { Scope } from '../../scope.js';
 export default class ModelService extends BaseService {
     protected options: OptionsInterface;
+    protected scope: Scope;
     private modelPermissionClassName;
     private modelRoleClassName;
     private map;
@@ -10,9 +12,9 @@ export default class ModelService extends BaseService {
     private readonly modelPermissionTable;
     private modelRoleQuery;
     private readonly modelRoleTable;
-    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>>;
+    constructor(options: OptionsInterface, scope: Scope, 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>>;
+    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>>;
     allByPermissionFor(modelType: string, permissionId: ModelIdType): Promise<any>;
 }

package/build/src/services/{model_service.js → models/model_service.js}

@@ -1,7 +1,8 @@
-import BaseService from './base_service.js';
-import { getModelPermissionModelQuery, getModelRoleModelQuery } from './query_helper.js';
+import BaseService from '../base_service.js';
+import { getModelPermissionModelQuery, getModelRoleModelQuery } from '../query_helper.js';
 export default class ModelService extends BaseService {
     options;
+    scope;
     modelPermissionClassName;
     modelRoleClassName;
     map;
@@ -9,9 +10,10 @@ export default class ModelService extends BaseService {
     modelPermissionTable;
     modelRoleQuery;
     modelRoleTable;
-    constructor(options, modelPermissionClassName, modelRoleClassName, map) {
-        super(options);
+    constructor(options, scope, modelPermissionClassName, modelRoleClassName, map) {
+        super(options, scope);
         this.options = options;
+        this.scope = scope;
         this.modelPermissionClassName = modelPermissionClassName;
         this.modelRoleClassName = modelRoleClassName;
         this.map = map;

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

@@ -1,15 +1,17 @@
-import { BaseModel } from '@adonisjs/lucid/orm';
-import { MorphInterface, OptionsInterface, PermissionInterface, PermissionModel } from '../../types.js';
+import { ModelManagerBindings, MorphInterface, OptionsInterface, PermissionInterface, PermissionModel } from '../../types.js';
 import BaseAdapter from '../base_adapter.js';
 import ModelManager from '../../model_manager.js';
+import { Emitter } from '@adonisjs/core/events';
+import { Scope } from '../../scope.js';
 export default class EmptyPermission extends BaseAdapter {
     protected manager: ModelManager;
     protected map: MorphInterface;
     protected options: OptionsInterface;
-    private permissionQuery;
-    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>>;
+    protected scope: Scope;
+    protected emitter: Emitter<any>;
+    permissionClassName: ModelManagerBindings['permission'];
+    constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, scope: Scope, emitter: Emitter<any>);
+    get permissionQuery(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    create(values: Partial<PermissionInterface>): Promise<PermissionModel<typeof import("../../models/permission.js").default>>;
+    delete(permission: string): Promise<boolean>;
 }

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

@@ -1,21 +1,24 @@
 import { getPermissionModelQuery } from '../query_helper.js';
 import BaseAdapter from '../base_adapter.js';
+import { PermissionCreatedEvent, PermissionDeletedEvent } from '../../events/index.js';
 export default class EmptyPermission extends BaseAdapter {
     manager;
     map;
     options;
-    permissionQuery;
+    scope;
+    emitter;
     permissionClassName;
-    constructor(manager, map, options) {
-        super(manager, map, options);
+    constructor(manager, map, options, scope, emitter) {
+        super(manager, map, options, scope, emitter);
         this.manager = manager;
         this.map = map;
         this.options = options;
+        this.scope = scope;
+        this.emitter = emitter;
         this.permissionClassName = manager.getModel('permission');
-        this.permissionQuery = getPermissionModelQuery(this.permissionClassName);
     }
-    delete(permission) {
-        return this.permissionQuery.where('slug', permission).delete();
+    get permissionQuery() {
+        return getPermissionModelQuery(this.permissionClassName, this.queryOptions);
     }
     async create(values) {
         if (!values.slug) {
@@ -23,11 +26,24 @@ export default class EmptyPermission extends BaseAdapter {
         }
         const search = {
             slug: values.slug,
-            scope: values.scope || this.getScope(),
+            scope: values.scope || this.getScope().get(),
         };
-        return (await this.permissionClassName.updateOrCreate(search, values));
+        values.scope = values.scope || this.getScope().get();
+        let permission = await this.permissionClassName.findBy(search);
+        if (!permission) {
+            permission = await this.permissionClassName.create(values);
+            this.fire(PermissionCreatedEvent, permission);
+        }
+        return permission;
     }
-    query() {
-        return this.permissionQuery;
+    async delete(permission) {
+        const deleted = await this.permissionQuery
+            .where('slug', permission)
+            .where('scope', this.getScope().get())
+            .delete();
+        if (deleted.length > 0) {
+            this.fire(PermissionDeletedEvent, permission);
+        }
+        return deleted.length > 0;
     }
 }