@via-profit/ability 3.0.1 → 3.1.1

package/dist/parsers/dsl/AbilityDSLLexer.d.ts

@@ -0,0 +1,24 @@
+import { AbilityDSLToken } from '../../parsers/dsl/AbilityDSLToken';
+export declare class AbilityDSLLexer {
+    private readonly input;
+    private pos;
+    private tokens;
+    private line;
+    private column;
+    private readonly keywords;
+    constructor(input: string);
+    tokenize(): AbilityDSLToken[];
+    private readComment;
+    private readString;
+    private readNumber;
+    private readSymbol;
+    private readWord;
+    private skipWhitespace;
+    private isDigit;
+    private isAlpha;
+    private isSymbol;
+    private isNewline;
+    private peek;
+    private advance;
+    private isAtEnd;
+}

package/dist/parsers/dsl/AbilityDSLParser.d.ts

@@ -0,0 +1,86 @@
+import AbilityPolicy from '../../core/AbilityPolicy';
+import { ResourceObject } from '../../core/AbilityParser';
+/**
+ * Parser for the Ability DSL.
+ *
+ * Converts a DSL string into one or more AbilityPolicy instances.
+ * The grammar follows the structure:
+ *
+ *   <effect> <permission> if <group> [ <group> ... ]
+ *
+ * where <group> is either "all of:" or "any of:", followed by a colon,
+ * and then a list of rules (one per line).
+ *
+ * Each rule is: <identifier> <operator> <value>
+ *
+ * Operators can be simple (equals, contains, in) or
+ * composed (is null, is not null, greater than, less than or equal, etc.).
+ */
+export declare class AbilityDSLParser<Resource extends ResourceObject = Record<string, unknown>, Environment = unknown> {
+    private dsl;
+    private tokens;
+    private pos;
+    private annotationBuffer;
+    constructor(dsl: string);
+    /**
+     * Main entry point: tokenize the input and parse all policies.
+     * @returns Array of AbilityPolicy instances.
+     */
+    parse(): readonly AbilityPolicy<Resource, Environment>[];
+    /**
+     * Parses a single policy from the current token position.
+     *
+     * Grammar:
+     *   policy = EFFECT PERMISSION IF (ALL | ANY) COLON ruleSets
+     */
+    private parsePolicy;
+    /**
+     * Parses a sequence of rule sets (groups) until a new policy starts or EOF.
+     */
+    private parseRuleSets;
+    /**
+     * Parses a single group, e.g. "all of:" or "any of:", and returns a RuleSet.
+     */
+    private parseGroup;
+    /**
+     * Parses a single rule: subject operator value
+     */
+    private parseRule;
+    /**
+     * Parses the comparison operator part of a rule.
+     * Returns both the resulting AbilityCondition and the token type that was consumed.
+     */
+    private parseConditionOperator;
+    /**
+     * Helper to match and consume a specific word token (KEYWORD or IDENTIFIER).
+     * @param word The exact string to look for.
+     * @returns True if the next token has that value.
+     */
+    private matchWord;
+    private matchSymbol;
+    /**
+     * Parses a resource value. Can be a string literal, number, boolean,
+     * null, a path (identifier), or an array.
+     */
+    private parseValue;
+    /**
+     * Parses an array literal: [ <value>, <value>, ... ]
+     * The opening bracket has already been consumed.
+     */
+    private parseArray;
+    private consumeLeadingComments;
+    private processCommentToken;
+    private takeAnnotations;
+    private syntaxError;
+    private getLine;
+    private suggest;
+    private levenshteinDistance;
+    private consumeOneOf;
+    private consume;
+    private check;
+    private isStartOfPolicy;
+    private isStartOfGroup;
+    private advance;
+    private peek;
+    private isAtEnd;
+}

package/dist/parsers/dsl/AbilityDSLSyntaxError.d.ts

@@ -0,0 +1,13 @@
+export declare class AbilityDSLSyntaxError extends Error {
+    readonly line: number;
+    readonly column: number;
+    readonly context: string;
+    readonly details: string;
+    private readonly _formattedMessage;
+    private readonly _originalStack?;
+    constructor(line: number, column: number, context: string, // строка DSL + ^ + соседние строки
+    details: string);
+    private static supportsColor;
+    private formatMessage;
+    toString(): string;
+}

package/dist/parsers/dsl/AbilityDSLToken.d.ts

@@ -0,0 +1,55 @@
+import AbilityCode from '../../core/AbilityCode';
+export type TokenType = 'EFFECT' | 'IF' | 'PERMISSION' | 'IDENTIFIER' | 'COLON' | 'COMMA' | 'DOT' | 'LBRACKET' | 'RBRACKET' | 'ALL' | 'ANY' | 'OF' | 'EOF' | 'COMMENT' | 'EQ' | 'CONTAINS' | 'IN' | 'NOT_IN' | 'NOT_CONTAINS' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'NULL' | 'EQ_NULL' | 'NOT_EQ_NULL' | 'NOT_EQ' | 'LEN_GT' | 'LEN_LT' | 'LEN_EQ' | 'STRING' | 'NUMBER' | 'BOOLEAN' | 'SYMBOL' | 'KEYWORD' | 'UNKNOWN';
+/**
+ * Represents a single token produced by the Ability DSL lexer.
+ * Each token carries a type (e.g., EFFECT, IDENTIFIER, STRING) and its raw string value.
+ */
+export declare class AbilityDSLToken<Code extends TokenType = TokenType> extends AbilityCode<Code> {
+    /** The literal text of the token as it appeared in the input (e.g., "permit", "user.roles", "admin"). */
+    readonly value: string;
+    /** The line number in DSL */
+    readonly line: number;
+    /** The column in dsl */
+    readonly column: number;
+    constructor(type: Code, value: string, line: number, column: number);
+    /**
+     * Returns a human-readable representation of the token, useful for debugging.
+     * Example output: "AbilityDSLToken([EFFECT] permit"
+     */
+    toString(): string;
+    static readonly EFFECT: TokenType;
+    static readonly IF: TokenType;
+    static readonly PERMISSION: TokenType;
+    static readonly IDENTIFIER: TokenType;
+    static readonly COLON: TokenType;
+    static readonly COMMA: TokenType;
+    static readonly DOT: TokenType;
+    static readonly LBRACKET: TokenType;
+    static readonly RBRACKET: TokenType;
+    static readonly ALL: TokenType;
+    static readonly ANY: TokenType;
+    static readonly OF: TokenType;
+    static readonly EOF: TokenType;
+    static readonly COMMENT: TokenType;
+    static readonly EQ: TokenType;
+    static readonly CONTAINS: TokenType;
+    static readonly IN: TokenType;
+    static readonly NOT_IN: TokenType;
+    static readonly NOT_CONTAINS: TokenType;
+    static readonly GT: TokenType;
+    static readonly GTE: TokenType;
+    static readonly LT: TokenType;
+    static readonly LTE: TokenType;
+    static readonly NULL: TokenType;
+    static readonly EQ_NULL: TokenType;
+    static readonly NOT_EQ_NULL: TokenType;
+    static readonly LEN_GT: TokenType;
+    static readonly LEN_LT: TokenType;
+    static readonly LEN_EQ: TokenType;
+    static readonly NOT_EQ: TokenType;
+    static readonly STRING: TokenType;
+    static readonly NUMBER: TokenType;
+    static readonly BOOLEAN: TokenType;
+    static readonly SYMBOL: TokenType;
+    static readonly KEYWORD: TokenType;
+}

package/dist/parsers/json/AbilityJSONParser.d.ts

@@ -0,0 +1,22 @@
+import { AbilityRule, AbilityRuleConfig } from '../../core/AbilityRule';
+import { AbilityRuleSet, AbilityRuleSetConfig } from '../../core/AbilityRuleSet';
+import { ResourceObject } from '../../core/AbilityParser';
+import { AbilityPolicy, AbilityPolicyConfig } from '../../core/AbilityPolicy';
+export declare class AbilityJSONParser {
+    /**
+     * Parses an array of policy configurations into an array of AbilityPolicy instances.
+     * @param configs - Array of policy configurations
+     * @returns Array of AbilityPolicy instances
+     */
+    static parse<Resource extends ResourceObject, Environment = unknown>(configs: readonly AbilityPolicyConfig[]): AbilityPolicy<Resource, Environment>[];
+    static parsePolicy<Resource extends ResourceObject = Record<string, unknown>, Environment = unknown>(config: AbilityPolicyConfig): AbilityPolicy<Resource, Environment>;
+    static parseRule<Resources extends object, Environment = unknown>(config: AbilityRuleConfig): AbilityRule<Resources, Environment>;
+    /**
+     * Parse the config JSON format to Group class instance
+     */
+    static parseRuleSet<Resource extends ResourceObject = Record<string, unknown>, Environment = unknown>(config: AbilityRuleSetConfig): AbilityRuleSet<Resource, Environment>;
+    static ruleToJSON(rule: AbilityRule): AbilityRuleConfig;
+    static ruleSetToJSON(ruleSet: AbilityRuleSet): AbilityRuleSetConfig;
+    static policyToJSON(policy: AbilityPolicy): AbilityPolicyConfig;
+    static toJSON(policies: readonly AbilityPolicy[]): AbilityPolicyConfig[];
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@via-profit/ability",
   "support": "https://via-profit.ru",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Via-Profit Ability service",
   "keywords": [
     "ability",
@@ -29,7 +29,8 @@
     "build:dist": "cross-env NODE_ENV=production webpack --config ./webpack/webpack-config.ts --color --progress",
     "build:playground": "cross-env NODE_ENV=development webpack --config ./webpack/webpack-config-playground.ts --color --progress",
     "playground": "npm run build:playground -- --watch",
-    "test": "jest"
+    "test": "jest",
+    "bench": "npm run build && node ./bench/benchmark.js"
   },
   "repository": {
     "type": "git",
@@ -45,7 +46,6 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "cross-env": "^7.0.3",
     "@eslint/js": "^9.13.0",
     "@jagi/jest-transform-graphql": "^1.0.2",
     "@jest/types": "^29.6.3",
@@ -55,6 +55,7 @@
     "@types/webpack": "^5.28.5",
     "@types/webpack-bundle-analyzer": "^4.7.0",
     "concurrently": "^9.0.1",
+    "cross-env": "^7.0.3",
     "eslint": "^9.13.0",
     "globals": "^15.11.0",
     "jest": "^29.7.0",
@@ -63,6 +64,7 @@
     "nodemon": "^3.1.7",
     "nodemon-webpack-plugin": "^4.8.2",
     "prettier": "^3.3.3",
+    "tinybench": "^6.0.0",
     "ts-jest": "^29.2.5",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.2",

package/dist/AbilityCondition.d.ts

@@ -1,16 +0,0 @@
-import AbilityCode from './AbilityCode';
-export type AbilityConditionCodeType = '=' | '<>' | '>' | '<' | '>=' | '<=' | 'in' | 'not in';
-export type AbilityConditionLiteralType = 'equal' | 'not_equal' | 'more_than' | 'less_than' | 'less_or_equal' | 'more_or_equal' | 'in' | 'not_in';
-export declare class AbilityCondition extends AbilityCode<AbilityConditionCodeType> {
-    static equal: AbilityCondition;
-    static not_equal: AbilityCondition;
-    static more_than: AbilityCondition;
-    static less_than: AbilityCondition;
-    static less_or_equal: AbilityCondition;
-    static more_or_equal: AbilityCondition;
-    static in: AbilityCondition;
-    static not_in: AbilityCondition;
-    static fromLiteral(literal: AbilityConditionLiteralType): AbilityCondition;
-    get literal(): AbilityConditionLiteralType;
-}
-export default AbilityCondition;

package/dist/AbilityResolver.d.ts

@@ -1,32 +0,0 @@
-import AbilityPolicy from './AbilityPolicy';
-import AbilityPolicyEffect from './AbilityPolicyEffect';
-import { AbilityExplain } from '~/AbilityExplain';
-export declare class AbilityResolver<Resources extends object = object> {
-    policies: readonly AbilityPolicy<Resources>[];
-    constructor(policyOrListOfPolicies: readonly AbilityPolicy<Resources>[] | AbilityPolicy<Resources>);
-    /**
-     * Resolve policy for the resource and action
-     *
-     @param action - Action
-     * @param resource - Resource
-     */
-    resolve<Action extends keyof Resources>(action: Action, resource: Resources[Action]): this;
-    resolveWithExplain<Action extends keyof Resources>(action: Action, resource: Resources[Action]): readonly AbilityExplain[];
-    enforce<Action extends keyof Resources>(action: Action, resource: Resources[Action]): void | never;
-    /**
-     * Get the last effect of the policy
-     *
-     * @returns {AbilityPolicyEffect | null}
-     */
-    getEffect(): AbilityPolicyEffect | null;
-    isPermit(): boolean;
-    isDeny(): boolean;
-    getMatchedPolicy(): AbilityPolicy<Resources> | null;
-    /**
-     * Check if the action is contained in another action
-     * @param actionA - The first action to check
-     * @param actionB - The second action to check
-     */
-    static isInActionContain(actionA: string, actionB: string): boolean;
-}
-export default AbilityResolver;

package/dist/AbilityRule.d.ts

@@ -1,78 +0,0 @@
-import AbilityMatch from './AbilityMatch';
-import AbilityCondition, { AbilityConditionCodeType } from './AbilityCondition';
-export type AbilityRuleConfig = {
-    readonly id?: string | null;
-    readonly name?: string | null;
-    /**
-     * Subject key path like a 'user.name'
-     */
-    readonly subject: string;
-    /**
-     * Resource key path like a 'user.name' or value
-     */
-    readonly resource: string | number | boolean | (string | number)[];
-    readonly condition: AbilityConditionCodeType;
-};
-export type AbilityRuleConstructorProps = Omit<AbilityRuleConfig, 'condition'> & {
-    readonly condition: AbilityCondition;
-};
-/**
- * Represents a rule that defines a condition to be checked against a subject and resource.
- */
-export declare class AbilityRule<Resources extends object = object> {
-    /**
-     * Subject key path like a 'user.name'
-     */
-    subject: string;
-    /**
-     * Resource key path like a 'user.name' or value
-     */
-    resource: string | number | boolean | (string | number)[];
-    condition: AbilityCondition;
-    name: string;
-    id: string;
-    state: AbilityMatch;
-    /**
-     * Creates an instance of AbilityRule.
-     * @param {string} options.id - The unique identifier of the rule.
-     * @param {string} options.name - The name of the rule.
-     * @param {AbilityCondition} options.condition - The condition to evaluate.
-     * @param {string} options.subject - The subject of the rule.
-     * @param {string} options.resource - The resource to compare against.
-     * @param params
-     */
-    constructor(params: AbilityRuleConstructorProps);
-    /**
-     * Check if the rule is matched
-     * @param resource - The resource to check
-     */
-    check(resource: Resources | null): AbilityMatch;
-    /**
-     * Extract values from the resourceData
-     * @param resourceData - The resourceData to extract values from
-     */
-    extractValues(resourceData: Resources | null): [
-        string | number | boolean | (string | number)[] | null | undefined,
-        string | number | boolean | (string | number)[] | null | undefined
-    ];
-    /**
-     * Get the value of the object by dot notation
-     * @param resource - The object to get the value from
-     * @param desc - The dot notation string
-     */
-    getDotNotationValue<T = unknown>(resource: unknown, desc: string): T | undefined;
-    static parse<Resources extends object>(config: AbilityRuleConfig): AbilityRule<Resources>;
-    /**
-     * Export the rule to config object
-     */
-    export(): AbilityRuleConfig;
-    static equal<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static notIn<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static in<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static notEqual<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static lessThan<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static lessOrEqual<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static moreThan<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-    static moreOrEqual<Resources extends object = object>(subject: string, resource: AbilityRuleConfig['resource']): AbilityRule<Resources>;
-}
-export default AbilityRule;