@holoyan/adonisjs-permissions 0.1.0

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

@@ -0,0 +1,152 @@
+import { destructTarget, morphMap } from '../helper.js';
+export class RoleHasModelPermissions {
+    role;
+    permissionService;
+    modelService;
+    constructor(role, permissionService, modelService) {
+        this.role = role;
+        this.permissionService = permissionService;
+        this.modelService = modelService;
+    }
+    models() {
+        return this.modelService.all(this.role.getModelId());
+    }
+    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
+        const map = await morphMap();
+        return this.permissionService.direct(map.getAlias(this.role), this.role.getModelId());
+    }
+    async globalPermissions() {
+        const map = await morphMap();
+        return this.permissionService.directGlobal(map.getAlias(this.role), this.role.getModelId());
+    }
+    async onResourcePermissions() {
+        const map = await morphMap();
+        return this.permissionService.directResource(map.getAlias(this.role), this.role.getModelId());
+    }
+    async containsPermission(permisison) {
+        const map = await morphMap();
+        const result = await this.permissionService.containsAny(map.getAlias(this.role), this.role.getModelId(), [permisison]);
+        return result;
+    }
+    /**
+     *
+     * @param permisisons
+     * @returns
+     */
+    async containsAllPermissions(permisisons) {
+        const map = await morphMap();
+        const result = await this.permissionService.containsAll(map.getAlias(this.role), this.role.getModelId(), permisisons);
+        return result;
+    }
+    /**
+     *
+     * @param permisisons
+     * @returns
+     */
+    async containsAnyPermissions(permisisons) {
+        const map = await morphMap();
+        const result = await this.permissionService.containsAny(map.getAlias(this.role), this.role.getModelId(), permisisons);
+        return result;
+    }
+    async hasPermission(permisison, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        const result = await this.permissionService.hasAny(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId);
+        return result;
+    }
+    /**
+     *
+     * @param permisisons
+     * @returns
+     */
+    async hasAllPermissions(permisisons, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        const result = await this.permissionService.hasAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+        return result;
+    }
+    /**
+     *
+     * @param permisisons
+     * @returns
+     */
+    async hasAnyPermissions(permisisons, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        const result = await this.permissionService.hasAny(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+        return result;
+    }
+    /**
+     *
+     * @param permisison
+     * @returns
+     */
+    can(permisison) {
+        return this.hasPermission(permisison);
+    }
+    canAll(permisisons) {
+        return this.hasAllPermissions(permisisons);
+    }
+    canAny(permisisons) {
+        return this.hasAnyPermissions(permisisons);
+    }
+    async forbidden(permisison, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.forbidden(map.getAlias(this.role), this.role.getModelId(), permisison, entity.targetClass, entity.targetId);
+    }
+    assign(permisison, target) {
+        return this.give(permisison, target);
+    }
+    async give(permisison, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.giveAll(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId, true);
+    }
+    async giveAll(permisisons, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.giveAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId, true);
+    }
+    assingAll(permisisons, target) {
+        return this.giveAll(permisisons, target);
+    }
+    async revokePermission(permisison) {
+        return this.revoke(permisison);
+    }
+    async revoke(permisison) {
+        return this.revokeAll([permisison]);
+    }
+    async revokeAll(permisisons, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.revokeAll(map.getAlias(this.role), this.role.getModelId(), permisisons, entity.targetClass, entity.targetId);
+    }
+    async revokeAllPermissions(permisisons) {
+        return this.revokeAll(permisisons);
+    }
+    async flush() {
+        const map = await morphMap();
+        return this.permissionService.flush(map.getAlias(this.role), this.role.getModelId());
+    }
+    async forbid(permisison, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.forbid(map.getAlias(this.role), this.role.getModelId(), permisison, entity.targetClass, entity.targetId);
+    }
+    async unforbid(permisison, target) {
+        const map = await morphMap();
+        const entity = await destructTarget(target);
+        return this.permissionService.unforbidAll(map.getAlias(this.role), this.role.getModelId(), [permisison], entity.targetClass, entity.targetId);
+    }
+}

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

@@ -0,0 +1,16 @@
+import Role from '../../models/role.js';
+import { AclModel } from '../../types.js';
+import BaseService from '../base_service.js';
+export default class RolesService extends BaseService {
+    private modelRolesQuery;
+    all(modelType: string, modelId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<typeof Role, Role>;
+    has(modelType: string, modelId: number, role: string | Role): Promise<boolean>;
+    hasAll(modelType: string, modelId: number, roles: (string | Role)[]): Promise<boolean>;
+    hasAny(modelType: string, modelId: number, roles: (string | Role)[]): Promise<boolean>;
+    assign(role: string | Role, modelType: string, modelId: number): Promise<boolean>;
+    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<typeof Role, Role>;
+    flush(modelType: string, modelId: number): Promise<void>;
+}

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

@@ -0,0 +1,89 @@
+import Role from '../../models/role.js';
+import ModelRole from '../../models/model_role.js';
+import BaseService from '../base_service.js';
+import ModelPermission from '../../models/model_permission.js';
+import { morphMap } from '../helper.js';
+export default class RolesService extends BaseService {
+    modelRolesQuery(modelType, modelId) {
+        return Role.query()
+            .join(ModelRole.table + ' as mr', 'mr.role_id', '=', Role.table + '.id')
+            .where('mr.model_type', modelType)
+            .where('mr.model_id', modelId);
+    }
+    all(modelType, modelId) {
+        return this.modelRolesQuery(modelType, modelId).select(Role.table + '.*');
+    }
+    async has(modelType, modelId, role) {
+        return this.hasAll(modelType, modelId, [role]);
+    }
+    async hasAll(modelType, modelId, roles) {
+        const rolesQuery = this.modelRolesQuery(modelType, modelId);
+        let { slugs, ids } = this.formatList(roles);
+        if (slugs.length) {
+            rolesQuery.whereIn(Role.table + '.slug', slugs);
+        }
+        if (ids.length) {
+            rolesQuery.whereIn(Role.table + '.id', ids);
+        }
+        const r = await rolesQuery.count('* as total');
+        // @ts-ignore
+        return r[0].total === roles.length;
+    }
+    async hasAny(modelType, modelId, roles) {
+        // if is string then we are going to check against slug
+        // map roles
+        const rolesQuery = this.modelRolesQuery(modelType, modelId);
+        let { slugs, ids } = this.formatList(roles);
+        if (slugs.length) {
+            rolesQuery.whereIn(Role.table + '.slug', slugs);
+        }
+        if (ids.length) {
+            rolesQuery.whereIn(Role.table + '.id', ids);
+        }
+        const r = await rolesQuery.count('* as total');
+        // @ts-ignore
+        return r[0].total > 0;
+    }
+    async assign(role, modelType, modelId) {
+        const r = await this.extractRoleModel(role);
+        if (!r) {
+            throw new Error('Role  not found');
+        }
+        await ModelRole.create({
+            modelType,
+            modelId,
+            roleId: r.id,
+        });
+        return true;
+    }
+    async revoke(role, model) {
+        return this.revokeAll([role], model);
+    }
+    async revokeAll(roles, model) {
+        const map = await morphMap();
+        const { slugs, ids } = this.formatListStringNumbers(roles);
+        await ModelRole.query()
+            .leftJoin(Role.table + ' as r', 'r.id', '=', ModelRole.table + '.role_id')
+            .where('model_type', map.getAlias(model))
+            .where('model_id', model.getModelId())
+            .where((query) => {
+            query.whereIn('r.id', ids).orWhereIn('r.slug', slugs);
+        })
+            .delete();
+        return true;
+    }
+    async extractRoleModel(role) {
+        if (typeof role === 'string') {
+            return await Role.query().where('slug', role).first();
+        }
+        return role;
+    }
+    roleModelPermissionQuery(modelType) {
+        return Role.query()
+            .leftJoin(ModelPermission.table + ' as mp', 'mp.model_id', '=', Role.table + '.id')
+            .where('mp.model_type', modelType);
+    }
+    async flush(modelType, modelId) {
+        ModelRole.query().where('model_type', modelType).where('model_id', modelId).delete();
+    }
+}

package/build/src/types.d.ts

@@ -0,0 +1,21 @@
+import { LucidModel } from '@adonisjs/lucid/types/model';
+export interface Permissions {
+    tables: Object;
+}
+export interface AclModelInterface {
+    getModelId(): number;
+}
+export type AclModel = LucidModel & AclModelInterface;
+export interface AclModelQuery {
+    modelType: string;
+    modelId: number;
+}
+export interface ModelPermissionsQuery extends AclModelQuery {
+    permissionSlugs: string[];
+    permissionIds: number[];
+    directPermissions: boolean;
+    includeForbiddens: boolean;
+}
+export interface MorphMapInterface {
+    [key: string]: any;
+}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/stubs/configs/permissions.stub

@@ -0,0 +1,20 @@
+{{{
+  exports({
+    to: app.configPath('permissions.ts')
+  })
+}}}
+
+import { Permissions } from '@holoyan/adonisjs-permissions/types'
+
+export const permissionsConfig: Permissions = {
+  tables: {
+    roles: 'roles',
+    modelRoles: 'model_roles',
+    permissions: 'permissions',
+    modelPermissions: 'model_permissions',
+  },
+  morphMaps: {
+    roles: 'roles',
+    permissions: 'permissions',
+  }
+}

package/build/stubs/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export declare const stubsRoot: string;

package/build/stubs/main.js

@@ -0,0 +1,7 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export const stubsRoot = dirname(fileURLToPath(import.meta.url));

package/build/stubs/migrations/create_db.stub

@@ -0,0 +1,97 @@
+{{{
+  exports({
+    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')
+
+      table.string('slug').index()
+      table.string('title')
+      table.string('entity_type')
+      table.bigint('entity_id').unsigned()
+      table.integer('scope').unsigned()
+      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.unique(['slug', 'scope'])
+      table.index(['entity_type', 'entity_id'])
+    })
+
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.modelRoles'), (table) => {
+      table.increments('id')
+
+      table.string('model_type')
+      table.bigint('model_id').unsigned()
+      table.bigInteger('role_id').unsigned()
+
+      /**
+       * 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(config.get('permissions.permissionsConfig.tables.permissions'), (table) => {
+      table.increments('id')
+
+      table.string('slug').index()
+      table.string('title')
+      table.string('entity_type')
+      table.bigint('entity_id').unsigned()
+      table.integer('scope').unsigned()
+      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.unique(['slug', 'scope'])
+      table.index(['entity_type', 'entity_id'])
+    })
+
+    this.schema.createTable(config.get('permissions.permissionsConfig.tables.modelPermissions'), (table) => {
+      table.increments('id')
+
+      table.string('model_type')
+      table.bigint('model_id').unsigned()
+      table.bigInteger('permission_id').unsigned()
+
+      /**
+       * 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')
+    })
+
+  }
+
+  async down() {
+    this.schema.dropTable(config.get('permissions.permissionsConfig.tables.modelRoles'))
+    this.schema.dropTable(config.get('permissions.permissionsConfig.tables.roles'))
+    this.schema.dropTable(config.get('permissions.permissionsConfig.tables.modelPermissions'))
+    this.schema.dropTable(config.get('permissions.permissionsConfig.tables.permissions'))
+  }
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@holoyan/adonisjs-permissions",
+  "description": "Adonisjs roles and permissions system",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=18.16.0"
+  },
+  "type": "module",
+  "files": [
+    "build/src",
+    "build/providers",
+    "build/stubs",
+    "build/index.d.ts",
+    "build/index.js",
+    "build/configure.d.ts",
+    "build/configure.js"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./role_permission_provider": "./build/providers/role_permission_provider.js",
+    "./types": "./build/src/types.js"
+  },
+  "scripts": {
+    "clean": "del-cli build",
+    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext=.ts",
+    "format": "prettier --write .",
+    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
+    "pretest": "npm run lint",
+    "test": "c8 npm run quick:test",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "tsc",
+    "postbuild": "npm run copy:templates",
+    "release": "np",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "holoyan",
+  "license": "MIT",
+  "devDependencies": {
+    "@adonisjs/assembler": "^7.0.0",
+    "@adonisjs/core": "^6.2.0",
+    "@adonisjs/eslint-config": "^1.2.1",
+    "@adonisjs/lucid": "^20.1.0",
+    "@adonisjs/prettier-config": "^1.2.1",
+    "@adonisjs/tsconfig": "^1.2.1",
+    "@japa/assert": "^2.1.0",
+    "@japa/runner": "^3.1.1",
+    "@swc/core": "^1.3.102",
+    "@types/chance": "^1.1.6",
+    "@types/luxon": "^3.4.2",
+    "@types/node": "^20.10.7",
+    "c8": "^9.0.0",
+    "chance": "^1.1.11",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.0.0",
+    "eslint": "^8.38.0",
+    "np": "^9.2.0",
+    "pg": "^8.11.3",
+    "prettier": "^3.1.1",
+    "sqlite3": "^5.1.7",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^6.2.0",
+    "@adonisjs/lucid": "^20.1.0",
+    "luxon": "^3.4.4"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/package"
+  },
+  "prettier": "@adonisjs/prettier-config"
+}