// Basic expressions
has_permissions('profile:read')
 
// Basic combinations
has_permissions('transactions:read' || 'financials:manage')
 
// Compound expressions, with parentheses
has_permissions(('transactions:read' && 'expenses:read') || 'financials:manage')

class Interpreter {
  constructor(permissions) {
    this.permissions = permissions || [];
  }
 
  exec(expr) {
    if (expr instanceof lang.UnaryExpr) {
      return this.permissions.includes(expr.value);
    }
 
    if (expr instanceof lang.BinaryExpr) {
      switch (expr.op) {
      case '&&':
        return this.exec(expr.left) && this.exec(expr.right);
      case '||':
        return this.exec(expr.left) || this.exec(expr.right);
      default:
        throw Error(`RuntimeError: invalid operator ${expr.op}`);
      }
    }
 
    throw Error(`RuntimeError: unsupported expression type ${expr}`);
  }
}

const lang = require('./minilang');
const runtime = require('./runtime');
 
const trxRead = new lang.Permission('transactions:read');
const trxWrite = new lang.Permission('transactions:read');
const finManage = new lang.Permission('financials:manage');
const userPerms = ['transactions:read', 'expenses:read'];
 
const int = new runtime.Interpreter(userPerms);
const trxReadAndWrite = trxRead.and(trxWrite);
 
console.log(`User can read/write transactions: ${int.exec(trxReadAndWrite)}`);
> User can read/write transactions: true
 
 
console.log(`User can manage financials: ${int.exec(finManage)}`);
> User can manage financials: false
 
 
int.permissions = ['financials:manage'];
console.log(`User can manage financials: ${int.exec(perms)}`);
> User can manage financials: true