@via-profit/ability 3.6.1 → 3.6.2

package/dist/index.d.ts

@@ -218,14 +218,16 @@ type AbilityExplainConfig = {
     readonly type: AbilityExplainType;
     readonly name: string;
     readonly match: AbilityMatchType;
+    readonly debugInfo?: boolean;
 };
 declare class AbilityExplain {
     readonly type: AbilityExplainType;
     readonly children: AbilityExplain[];
     readonly name: string;
     readonly match: AbilityMatchType;
+    readonly debugInfo?: boolean;
     constructor(config: AbilityExplainConfig, children?: AbilityExplain[]);
-    toString(indent?: number): string;
+    toString(indentPrefix?: string, isLast?: boolean): string;
 }
 declare class AbilityExplainRule extends AbilityExplain {
     constructor(rule: AbilityRule);
@@ -551,6 +553,7 @@ declare class AbilityDSLParser<R extends ResourceObject = Record<string, unknown
     private takeAnnotations;
     private isStartOfPolicy;
     private isStartOfGroup;
+    private isStartOfRule;
     private isStartOfExcept;
     private isStartOfAlias;
 }

package/dist/index.js

@@ -126,27 +126,49 @@ const AbilityMatch = {
     disabled: brand$2('disabled'),
 };
 
+const colors = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    blue: '\x1b[34m',
+    yellow: '\x1b[33m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
 class AbilityExplain {
     type;
     children;
     name;
     match;
+    debugInfo;
     constructor(config, children = []) {
         this.type = config.type;
         this.children = children;
         this.name = config.name;
         this.match = config.match;
-    }
-    toString(indent = 0) {
-        const pad = ' '.repeat(indent);
-        const mark = this.match === AbilityMatch.match ? '✓' : '✗';
-        let out = '';
-        if (this.type === 'policy') {
-            out += '\n';
-        }
-        out += `${pad}${mark} ${this.type} «${this.name}» is ${this.match}`;
-        this.children.forEach(child => {
-            out += '\n' + child.toString(indent + 1);
+        this.debugInfo = config.debugInfo;
+    }
+    toString(indentPrefix = '', isLast = true) {
+        const isMatch = this.match === AbilityMatch.match;
+        const mark = isMatch ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+        const label = this.type === 'policy'
+            ? `${colors.blue}POLICY${colors.reset}`
+            : this.type === 'ruleSet'
+                ? `${colors.yellow}RULESET${colors.reset}`
+                : `${colors.white}RULE${colors.reset}`;
+        const branch = indentPrefix.length === 0
+            ? ''
+            : isLast
+                ? `${colors.gray}└─${colors.reset} `
+                : `${colors.gray}├─${colors.reset} `;
+        let out = `${indentPrefix}${branch}${label} ${this.name} — ${mark}`;
+        if (this.debugInfo) {
+            out += ` ${colors.gray}(${this.debugInfo})${colors.reset}`;
+        }
+        const nextIndent = indentPrefix + (isLast ? '   ' : `${colors.gray}│  ${colors.reset}`);
+        this.children.forEach((child, index) => {
+            const last = index === this.children.length - 1;
+            out += '\n' + child.toString(nextIndent, last);
         });
         return out;
     }
@@ -1500,32 +1522,32 @@ class AbilityJSONParser {
         return {
             id: rule.id,
             name: rule.name,
+            disabled: rule.disabled,
             subject: rule.subject,
             resource: rule.resource,
             condition: rule.condition,
-            disabled: rule.disabled,
         };
     }
     static ruleSetToJSON(ruleSet) {
         return {
             id: ruleSet.id.toString(),
             name: ruleSet.name.toString(),
+            disabled: ruleSet.disabled,
             compareMethod: ruleSet.compareMethod,
             rules: ruleSet.rules.map(rule => AbilityJSONParser.ruleToJSON(rule)),
-            disabled: ruleSet.disabled,
         };
     }
     static policyToJSON(policy) {
         return {
             id: policy.id.toString(),
             name: policy.name.toString(),
-            compareMethod: policy.compareMethod,
-            ruleSet: policy.ruleSet.map(ruleSet => AbilityJSONParser.ruleSetToJSON(ruleSet)),
+            disabled: policy.disabled,
+            priority: policy.priority,
             permission: policy.permission,
             effect: policy.effect,
-            priority: policy.priority,
-            disabled: policy.disabled,
+            compareMethod: policy.compareMethod,
             tags: policy.tags,
+            ruleSet: policy.ruleSet.map(ruleSet => AbilityJSONParser.ruleSetToJSON(ruleSet)),
         };
     }
     static toJSON(policies) {
@@ -2313,28 +2335,34 @@ class AbilityDSLParser {
      */
     parseRuleSets(policyCompareMethod) {
         const sets = [];
+        this.consumeLeadingComments();
+        this.consumeLeadingAnnotations();
         while (!this.stream.eof() && !this.isStartOfPolicy()) {
-            this.consumeLeadingComments();
-            this.consumeLeadingAnnotations();
-            // Если начинается новая except группа — парсим её
+            // maybe except ruleSet
             if (this.isStartOfExcept()) {
                 sets.push(this.parseExceptGroup(policyCompareMethod));
                 continue;
             }
-            // Если начинается новая группа — парсим её
+            // maybe ruleSet
             if (this.isStartOfGroup()) {
                 sets.push(this.parseGroup());
                 continue;
             }
-            const annotation = this.takeAnnotations('ruleSet');
+            // implicit ruleSet
+            // if (!this.isStartOfRule()) {
+            //   this.consumeLeadingComments();
+            //   this.consumeLeadingAnnotations();
+            // }
+            // is implicit group
+            // const annotation = this.takeAnnotations('ruleSet');
             const group = new AbilityRuleSet({
-                id: annotation.id?.value || null,
+                // id: annotation.id?.value || null,
                 compareMethod: policyCompareMethod,
-                name: annotation.name?.value ?? null,
-                description: annotation.description?.value || null,
-                disabled: annotation.disabled?.value ?? undefined,
+                // name: annotation.name?.value ?? null,
+                // description: annotation.description?.value || null,
+                // disabled: annotation.disabled?.value ?? undefined,
             });
-            // Читаем правила implicit-группы
+            // Read rules of implicit-группы
             while (!this.stream.eof()) {
                 this.consumeLeadingComments();
                 this.consumeLeadingAnnotations();
@@ -2935,6 +2963,11 @@ class AbilityDSLParser {
     isStartOfGroup() {
         return this.stream.check(TokenTypes.ALL) || this.stream.check(TokenTypes.ANY);
     }
+    isStartOfRule() {
+        return (this.stream.check(TokenTypes.IDENTIFIER) ||
+            this.stream.check(TokenTypes.ALWAYS) ||
+            this.stream.check(TokenTypes.NEVER));
+    }
     isStartOfExcept() {
         return this.stream.check(TokenTypes.EXCEPT);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@via-profit/ability",
   "support": "https://via-profit.ru",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "description": "Via-Profit Ability service",
   "keywords": [
     "ability",