@holoyan/adonisjs-permissions 0.5.2 → 0.6.8

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 + '.*');
     }
@@ -312,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) {
@@ -352,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) {
@@ -384,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) {
@@ -402,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) {
@@ -414,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');
@@ -478,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,13 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
+import { RoleInterface, RoleModel, 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>>;
+    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,16 +1,33 @@
 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`
         return this.roleQuery.where('slug', role).delete();
     }
+    async create(values) {
+        if (!values.slug) {
+            throw new Error('The attribute slug is required');
+        }
+        const search = {
+            slug: values.slug,
+            scope: values.scope || this.getScope(),
+        };
+        return (await this.roleClassName.updateOrCreate(search, values));
+    }
     query() {
         return this.roleQuery;
     }

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);
@@ -110,14 +115,20 @@ 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();
+            if (slugs.length) {
+                query.orWhereIn('r.slug', slugs);
+            }
+            if (ids.length) {
+                query.orWhereIn('r.id', ids);
+            }
+        });
+        this.applyModelRoleScopes(q, 'r', this.currentScope);
+        await q.delete();
         return true;
     }
     async extractRoleModel(roles) {
@@ -142,4 +153,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/build/stubs/migrations/create_db.stub

@@ -3,17 +3,16 @@
     to: app.makePath('database', 'migrations', prefix + '_create_role_permissions_table.ts')
   })
 }}}
-
 import { BaseSchema } from '@adonisjs/lucid/schema'
 import config from "@adonisjs/core/services/config";
 
 export default class extends BaseSchema {
 
   async up() {
-    this.schema.createTable(config.get('permissions.permissionsConfig.tables.roles'), (table) => {
-      table.increments('id')
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.permissions'), (table) => {
+      table.bigIncrements('id')
 
-      table.string('slug').index()
+      table.string('slug')
       table.string('title').nullable()
       table.string('entity_type').defaultTo('*')
       table.bigint('entity_id').unsigned().nullable()
@@ -26,16 +25,19 @@ export default class extends BaseSchema {
       table.timestamp('created_at', { useTz: true })
       table.timestamp('updated_at', { useTz: true })
 
-      table.unique(['slug', 'scope'])
+      table.index(['slug', 'scope'])
       table.index(['entity_type', 'entity_id'])
     })
 
-    this.schema.createTable(config.get('permissions.permissionsConfig.tables.modelRoles'), (table) => {
-      table.increments('id')
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.roles'), (table) => {
+      table.bigIncrements('id')
 
-      table.string('model_type')
-      table.bigint('model_id').unsigned()
-      table.bigInteger('role_id').unsigned()
+      table.string('slug')
+      table.string('title').nullable()
+      table.string('entity_type').defaultTo('*')
+      table.bigint('entity_id').unsigned().nullable()
+      table.integer('scope').unsigned().defaultTo(0)
+      table.boolean('allowed').defaultTo(true)
 
       /**
        * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
@@ -43,20 +45,16 @@ export default class extends BaseSchema {
       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')
+      table.index(['slug', 'scope'])
+      table.index(['entity_type', 'entity_id'])
     })
 
-    this.schema.createTable(config.get('permissions.permissionsConfig.tables.permissions'), (table) => {
-      table.increments('id')
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.modelRoles'), (table) => {
+      table.bigIncrements('id')
 
-      table.string('slug').index()
-      table.string('title').nullable()
-      table.string('entity_type').defaultTo('*')
-      table.bigint('entity_id').unsigned().nullable()
-      table.integer('scope').unsigned().defaultTo('*')
-      table.boolean('allowed').defaultTo(true)
+      table.string('model_type')
+      table.bigint('model_id').unsigned()
+      table.bigInteger('role_id').unsigned()
 
       /**
        * Uses timestamptz for PostgreSQL and DATETIME2 for MSSQL
@@ -64,12 +62,13 @@ export default class extends BaseSchema {
       table.timestamp('created_at', { useTz: true })
       table.timestamp('updated_at', { useTz: true })
 
-      table.unique(['slug', 'scope'])
-      table.index(['entity_type', 'entity_id'])
+      table.index(['model_type', 'model_id'])
+
+      table.foreign('role_id').references('roles.id').onDelete('CASCADE')
     })
 
     this.schema.createTable(config.get('permissions.permissionsConfig.tables.modelPermissions'), (table) => {
-      table.increments('id')
+      table.bigIncrements('id')
 
       table.string('model_type')
       table.bigint('model_id').unsigned()

package/package.json

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