@holoyan/adonisjs-permissions 0.6.4 → 0.6.8

package/README.md

@@ -19,6 +19,7 @@
 - [Basic Usage](#basic-usage)
   - [Creating roles and permissions](#creating-roles-and-permissions)
   - [Assigning permissions to the roles (Globally)](#assigning-permissions-to-the-roles-globally)
+  - [Creating permission on a fly](#creating-permission-on-a-fly)
   - [Assigning permissions and roles to the users (models)](#assigning-permissions-and-roles-to-the-users-models)
   - [Multi-model support](#multi-model-support)
   - [Getting all roles for a user](#getting-all-roles-for-a-user)
@@ -39,7 +40,8 @@
   - [containsPermission v hasPermission](#containspermission-v-haspermission)
   - [Scopes or Multi-tenancy](#scopes-or-multi-tenancy)
     - [The Scope middleware](#the-scope-middleware) 
-    - [Default Scope](#default-scope-tenant) 
+    - [Default Scope](#default-scope-tenant)
+- [Cheat sheet](#cheat-sheet)
 - [Todo](#todo)
 - [Test](#test)
 - [License](#license)
@@ -172,10 +174,15 @@ On this section, we will explore basic role permission methods.
 
 Let's manually create `create,update,read,delete` permissions, as well as `admin,manager` roles
 
+> Look also [Creating permissions on a fly](#creating-permissions-on-a-fly) section
+
 ```typescript
 
 import { Permission } from '@holoyan/adonisjs-permissions'
 import { Role } from '@holoyan/adonisjs-permissions'
+import {Acl} from "@holoyan/adonisjs-permissions";
+
+
 
 
 // create permissions
@@ -188,12 +195,14 @@ const update = await Permission.create({
   slug:'update',
 })
 
-const read = await Permission.create({
-  slug:'read',
+// or create using Acl (recomended way)
+const read = await Acl.permission().create({
+  slug: 'read',
 })
 
-const delete = await Permission.create({
-  slug:'delete',
+
+const delete = await Acl.permission().create({
+  slug: 'delete',
 })
 
 // create roles
@@ -202,8 +211,9 @@ const admin = await Role.create({
   title:'Cool title for Admin', // optional
 })
 
-const manager = await Role.create({
-  slug:'manager',
+// or create using Acl (recomended way)
+const manager = await Acl.role().create({
+  slug: 'manager',
 })
 
 ```
@@ -228,13 +238,15 @@ await Acl.role(admin).giveAll(['read', 'delete'])
 
 ```
 
+### Creating permissions on a fly
+
 In case you are assigning a permission that is not already available, `Acl` will create new permission behind the scenes and assign them.
 
 ```typescript
 
-// uploadFile permissions not available
+// uploadFile permission not available
 await Acl.role(admin).allow('uploadFile')
-// uploadFile permission created and assigned
+// 'uploadFile' permission created and assigned
 
 ```
 
@@ -265,7 +277,7 @@ import {Acl} from "@holoyan/adonisjs-permissions";
 
 // create and assign a new permission
 Acl.model(user1).assignDirectPermission('upload-file-slug')
-// or use allow method
+// or use allow() method
 Acl.model(user1).allow('permissionSlug')
 ```
 
@@ -922,6 +934,11 @@ export default class PostController {
 > Default Scope value is equal to 0 (zero)
 
 
+## Cheat sheet
+
+Coming soon
+
+
 ## TODO
 
 - [X] Scopes (Multitenancy)

package/build/src/services/helper.js

@@ -10,7 +10,7 @@ export function formatList(models) {
         }
         else {
             // @ts-ignore
-            ids.push(model.id);
+            ids.push(+model.id);
         }
     }
     return { slugs, ids };
@@ -24,7 +24,7 @@ export function formatListStringNumbers(models) {
         }
         else {
             // @ts-ignore
-            ids.push(model);
+            ids.push(+model);
         }
     }
     return { slugs, ids };
@@ -41,7 +41,7 @@ export function formatStringNumbers(models) {
             ids.push(model);
         }
         else {
-            ids.push(model.id);
+            ids.push(+model.id);
         }
     }
     return { slugs, ids };

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

@@ -46,6 +46,7 @@ export declare class ModelHasRolePermissions {
     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[]>;

package/build/src/services/model_has_role_permissions.js

@@ -140,7 +140,10 @@ export class ModelHasRolePermissions {
         return this.permissionsService.giveAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId, true);
     }
     allow(permission, target) {
-        return this.assignDirectPermission(permission, target);
+        return this.allowAll([permission], target);
+    }
+    allowAll(permission, target) {
+        return this.assignDirectAllPermissions(permission, target);
     }
     async revokePermission(permission, target) {
         return this.revokeAllPermissions([permission], target);

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

@@ -1,5 +1,5 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ScopeInterface } from '../../types.js';
+import { PermissionInterface, PermissionModel, ScopeInterface } from '../../types.js';
 export default class EmptyPermission {
     private permissionClassName;
     private scope;
@@ -8,5 +8,6 @@ export default class EmptyPermission {
     on(scope: number): this;
     getScope(): number;
     delete(permission: 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").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    create(values: Partial<PermissionInterface>): Promise<PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    query(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
 }

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

@@ -16,10 +16,18 @@ export default class EmptyPermission {
         return this.scope.get();
     }
     delete(permission) {
-        // get all permissions by slug
-        // if there is permission with allowed false then check if it has `links`
         return this.permissionQuery.where('slug', permission).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.permissionClassName.updateOrCreate(search, values));
+    }
     query() {
         return this.permissionQuery;
     }

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

@@ -1,5 +1,5 @@
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ScopeInterface } from '../../types.js';
+import { RoleInterface, RoleModel, ScopeInterface } from '../../types.js';
 export default class EmptyRoles {
     private roleClassName;
     private scope;
@@ -8,5 +8,6 @@ export default class EmptyRoles {
     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

@@ -16,10 +16,18 @@ export default class EmptyRoles {
         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/roles_service.js

@@ -120,7 +120,12 @@ export default class RolesService extends BaseService {
             .where('model_type', this.map.getAlias(model))
             .where('model_id', model.getModelId())
             .where((query) => {
-            query.whereIn('r.id', ids).orWhereIn('r.slug', slugs);
+            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();

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.6.4",
+  "version": "0.6.8",
   "engines": {
     "node": ">=18.16.0"
   },