Git Product home page Git Product logo

axesor's Introduction

DEPRECATION NOTICE

This package is no longer maintained.

Build Status Coverage Maintainability Vulnerabilities Dependency Status Dev Dependency Status

Axesor

Axesor is tiny package for working with ACLs. Axesor using the accesscontrol package.

GitHub repository: https://github.com/AckeeCZ/axesor

Install

npm i --save axesor

Usage

import { Acl } from 'axesor';

// define all your grants
const grants = {
    admin: {
        video: {
            'create:any': ['*', '!views'],
            'read:any': ['*'],
            'update:any': ['*', '!views'],
            'delete:any': ['*']
        }
    },
    user: {
        video: {
            'create:own': ['*', '!rating', '!views'],
            'read:own': ['*'],
            'update:own': ['*', '!rating', '!views'],
            'delete:own': ['*']
        }
    }
};

// define options
const options = {
    getRoles: (user) => user.roles,     // required - return string[]
    logger: console,                    // optional
    ownerFunctions: {                   // optional - here you can specify ownership between resources
        video: (user, video) => user.id === video.userId,
    },
};

const ac = new Acl(grants, options);
// user = logged user
// .read(video, 'video')
//      - first argument is resource (for example row from database)
//      - second argument is string key - name of the resource you define in grants object
// returns
//      - granted: boolean      - if user is granted to read
//      - action: string        - read, create, update, delete
//      - roles: string[]       - user roles
//      - resource: string      - resource string key representation from grants object
//      - attributes: string[]  - JSON path string array of resource fields which user is allowed to read / update / create / delete - array of fields which you define in grants object
const permission = ac.can(user).read(video, 'video'); // .create(), .update(), .delete() with same arguments
// you can use filter function to filter fields from resource which user can manipulate with
// this function filters recursively
const allowedVideo = permission.filter(video);

Custom rules

  • You can define custom rules, these functions are called always when you are calling one of the read / update / create / delete functions
  • Custom rules returns inside the attributes field only [] or ['*'] - not allowed or allowed with all grants
  • Arguments:
    1. action - read / update / create / delete
    2. resource type - string resource key which you define in grants object
    3. custom function - with logged user and resource object, it must return boolean or you can throw an error
  • If rule is defined for some action and resource, the function will be called always when you call ac.can(user).read(booking, 'bookings') for example
  • Custom rules have greater importance then ownerFunctions, these functions will be called firstly
import { Acl, Action } from 'axesor';

const ac = new Acl({}, {}); // todo

ac.addRule(Action.update, 'bookings', (user, booking) => {
    if ((user.roles.includes('partner') && user.partnerId === booking.partnerId)
        || user.roles.includes('admin')) {
        return true;
    }
    throw new Error('You are not allowed to edit this booking');
});
ac.addRule(Action.update, 'bookings', (user, booking) => {
    if (booking.state === 'closed' && !user.roles.includes('admin')) {
        throw new Error('You are not allowed to edit closed booking');
    }
    return true;
});

Role inheritance

Create a role hierarchy via inheritance.

import { Acl, Action } from 'axesor';

const grants = {
    admin: {
        rocket: {
            'create:any': ['*'],
            'read:any': ['*'],
            'update:any': ['*'],
            'delete:any': ['*'],
        }
    },
    user: {
        bike: {
            'create:any': ['*'],
            'read:any': ['*'],
            'update:any': ['*'],
            'delete:any': ['*'],
        }
    }
};

const inheritance: {
    // admin extends user --> can manage rockets and bikes
    admin: 'user',
    // can also inherit multiple: admin: ['user']
}

const ac = new Acl(grants, { inheritance, // todo });
// alternatively add via method
const ac = new Acl(grants, { // todo });
ac.addRoleInheritance(inheritance)

Make sure to reference only roles defined in grants object. For more info, see roles.

Tests

npm run test

License

This project is licensed under MIT.

axesor's People

Contributors

llouka avatar smolijar avatar smoliji avatar stefanprokopdev avatar vlasy avatar

Watchers

 avatar  avatar  avatar

Forkers

llouka

axesor's Issues

Unnecessary permission attributes

This issue is side effect of the issue #6.

The part of code attributes: !attributes.includes('*') ? attributes : ['*'] in the Acl.ts on the line 116 was changed.

Now permission attributes will look like this: ['*', 'author', 'title'] if you grant access to the ['*', 'author', 'title']. The previous part of code should not be here because of exclude filters - ['*', '!name'] - result was ['*'].

We need to add some filter for this cases. If grants contains exclude then keep attributes and if not then use the * (only if * is defined).

The `!` filter doesnt work

I would like to do something like this: ['*', '!name'] - allow all fields but exclude name from it. It seems to be not working.

Owner function called multiple times

Is calling owner function for each match in grant intended feature or a bug? Example:

const axesor = require('axesor');

const grants = {
  admin: {
    video: {
      'read:own': ['*']
    }
  },
  reader: {
    video: {
      'read:own': ['*']
    }
  }
} 

const options = {
    getRoles: () => ['admin', 'reader'],
    ownerFunctions: {
      video: () => {
        console.log('video owner function')
      }
    }
};

const ac = new axesor.Acl(grants, options);

ac.can({}).read({ title: 'test' }, 'video');

video owner function is called twice in that case

https://repl.it/join/yvpignqp-jevhenijhorvat

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.