@vorionsys/security 1.0.0

package/dist/common/expression/evaluator.js

@@ -0,0 +1,326 @@
+/**
+ * Expression Evaluator for Vorion DSL
+ *
+ * Evaluates AST nodes against a context object to produce boolean results.
+ *
+ * Features:
+ * - Dotted identifier resolution (intent.action -> context.intent.action)
+ * - Type coercion for comparisons
+ * - Null-safe evaluation
+ * - LIKE pattern matching with wildcards
+ *
+ * @packageDocumentation
+ */
+/**
+ * Error thrown during evaluation
+ */
+export class EvaluatorError extends Error {
+    node;
+    context;
+    constructor(message, node, context) {
+        super(`Evaluation error: ${message}`);
+        this.node = node;
+        this.context = context;
+        this.name = 'EvaluatorError';
+    }
+}
+/**
+ * Resolve a dotted path in the context object
+ *
+ * @param path - Dotted path (e.g., "intent.action")
+ * @param context - Context object to resolve against
+ * @returns The resolved value or undefined if not found
+ *
+ * @example
+ * ```ts
+ * const context = { intent: { action: 'read' } };
+ * resolvePath('intent.action', context); // 'read'
+ * resolvePath('intent.missing', context); // undefined
+ * ```
+ */
+export function resolvePath(path, context) {
+    const parts = path.split('.');
+    let current = context;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Convert a value to a comparable primitive for comparison operations
+ */
+function toComparable(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    // Convert objects to string representation for comparison
+    return String(value);
+}
+/**
+ * Compare two values with type coercion
+ *
+ * @param left - Left operand
+ * @param right - Right operand
+ * @param operator - Comparison operator
+ * @returns Boolean result of comparison
+ */
+function compare(left, right, operator) {
+    const leftValue = toComparable(left);
+    const rightValue = toComparable(right);
+    // Null handling
+    if (leftValue === null || rightValue === null) {
+        switch (operator) {
+            case '==':
+                return leftValue === rightValue;
+            case '!=':
+                return leftValue !== rightValue;
+            default:
+                // For other operators, null comparisons always return false
+                return false;
+        }
+    }
+    // Type coercion for numeric comparisons
+    if (typeof leftValue === 'number' || typeof rightValue === 'number') {
+        const leftNum = Number(leftValue);
+        const rightNum = Number(rightValue);
+        // If conversion fails, fall through to string comparison
+        if (!isNaN(leftNum) && !isNaN(rightNum)) {
+            switch (operator) {
+                case '==':
+                    return leftNum === rightNum;
+                case '!=':
+                    return leftNum !== rightNum;
+                case '>':
+                    return leftNum > rightNum;
+                case '<':
+                    return leftNum < rightNum;
+                case '>=':
+                    return leftNum >= rightNum;
+                case '<=':
+                    return leftNum <= rightNum;
+            }
+        }
+    }
+    // String comparison (also handles booleans via string conversion)
+    const leftStr = String(leftValue);
+    const rightStr = String(rightValue);
+    switch (operator) {
+        case '==':
+            return leftStr === rightStr;
+        case '!=':
+            return leftStr !== rightStr;
+        case '>':
+            return leftStr > rightStr;
+        case '<':
+            return leftStr < rightStr;
+        case '>=':
+            return leftStr >= rightStr;
+        case '<=':
+            return leftStr <= rightStr;
+    }
+}
+/**
+ * Check if a value is in an array
+ *
+ * @param value - Value to check
+ * @param array - Array to check against
+ * @returns true if value is in array
+ */
+function checkIn(value, array) {
+    const comparableValue = toComparable(value);
+    for (const element of array) {
+        const comparableElement = toComparable(element);
+        // Handle null comparison
+        if (comparableValue === null && comparableElement === null) {
+            return true;
+        }
+        // String comparison for other values
+        if (comparableValue !== null && comparableElement !== null) {
+            if (String(comparableValue) === String(comparableElement)) {
+                return true;
+            }
+            // Also try numeric comparison
+            const numValue = Number(comparableValue);
+            const numElement = Number(comparableElement);
+            if (!isNaN(numValue) && !isNaN(numElement) && numValue === numElement) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if a value matches a LIKE pattern
+ *
+ * Supports wildcards:
+ * - % matches any sequence of characters (including empty)
+ * - _ matches any single character
+ *
+ * @param value - Value to check
+ * @param pattern - Pattern to match against
+ * @returns true if value matches pattern
+ */
+function checkLike(value, pattern) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    const valueStr = String(value);
+    const patternStr = String(pattern);
+    // Escape regex special characters except % and _
+    let regexPattern = patternStr
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/%/g, '.*')
+        .replace(/_/g, '.');
+    // Anchor the pattern
+    regexPattern = `^${regexPattern}$`;
+    try {
+        const regex = new RegExp(regexPattern, 'i');
+        return regex.test(valueStr);
+    }
+    catch {
+        // Invalid regex, fall back to exact match
+        return valueStr.toLowerCase() === patternStr.toLowerCase();
+    }
+}
+/**
+ * Evaluate a literal node
+ */
+function evaluateLiteral(node) {
+    return node.value;
+}
+/**
+ * Evaluate an identifier node
+ */
+function evaluateIdentifier(node, context) {
+    return resolvePath(node.name, context);
+}
+/**
+ * Evaluate an array expression node
+ */
+function evaluateArray(node, context) {
+    return node.elements.map((element) => evaluateNode(element, context));
+}
+/**
+ * Evaluate a comparison expression node
+ */
+function evaluateComparison(node, context) {
+    const left = evaluateNode(node.left, context);
+    const right = evaluateNode(node.right, context);
+    return compare(left, right, node.operator);
+}
+/**
+ * Evaluate an IN expression node
+ */
+function evaluateIn(node, context) {
+    const value = evaluateNode(node.value, context);
+    const array = evaluateArray(node.array, context);
+    return checkIn(value, array);
+}
+/**
+ * Evaluate a LIKE expression node
+ */
+function evaluateLike(node, context) {
+    const value = evaluateNode(node.value, context);
+    const pattern = evaluateNode(node.pattern, context);
+    return checkLike(value, pattern);
+}
+/**
+ * Evaluate a binary expression node (AND, OR)
+ */
+function evaluateBinary(node, context) {
+    const left = evaluateNode(node.left, context);
+    // Short-circuit evaluation
+    if (node.operator === 'AND') {
+        if (!toBool(left)) {
+            return false;
+        }
+        return toBool(evaluateNode(node.right, context));
+    }
+    // OR
+    if (toBool(left)) {
+        return true;
+    }
+    return toBool(evaluateNode(node.right, context));
+}
+/**
+ * Evaluate a unary expression node (NOT)
+ */
+function evaluateUnary(node, context) {
+    const operand = evaluateNode(node.operand, context);
+    return !toBool(operand);
+}
+/**
+ * Convert a value to boolean
+ */
+function toBool(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (typeof value === 'string') {
+        return value.length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+/**
+ * Evaluate an AST node
+ */
+function evaluateNode(node, context) {
+    switch (node.type) {
+        case 'Literal':
+            return evaluateLiteral(node);
+        case 'Identifier':
+            return evaluateIdentifier(node, context);
+        case 'ArrayExpression':
+            return evaluateArray(node, context);
+        case 'ComparisonExpression':
+            return evaluateComparison(node, context);
+        case 'InExpression':
+            return evaluateIn(node, context);
+        case 'LikeExpression':
+            return evaluateLike(node, context);
+        case 'BinaryExpression':
+            return evaluateBinary(node, context);
+        case 'UnaryExpression':
+            return evaluateUnary(node, context);
+        default:
+            throw new EvaluatorError(`Unknown node type: ${node.type}`, node, context);
+    }
+}
+/**
+ * Evaluate an AST against a context object
+ *
+ * @param ast - The AST to evaluate
+ * @param context - The context object to evaluate against
+ * @returns Boolean result of the evaluation
+ * @throws EvaluatorError if evaluation fails
+ *
+ * @example
+ * ```ts
+ * const ast = parse(tokenize("intent.action == 'read'"));
+ * const context = { intent: { action: 'read' } };
+ * evaluate(ast, context); // true
+ * ```
+ */
+export function evaluate(ast, context) {
+    const result = evaluateNode(ast, context);
+    return toBool(result);
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/common/expression/evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../src/common/expression/evaluator.ts"],"names":[],"mappings":"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"}

package/dist/common/expression/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Expression Engine for Vorion Governance DSL
+ *
+ * Provides a domain-specific language for expressing governance rules and conditions.
+ * This module combines lexer, parser, and evaluator into a unified API.
+ *
+ * Example expressions:
+ * - "intent.action == 'data:read' AND intent.riskScore > 50"
+ * - "user.role IN ['admin', 'supervisor'] OR trust.score >= 800"
+ * - "resource.sensitivity == 'high' AND NOT intent.approved"
+ *
+ * @packageDocumentation
+ */
+import { Token } from './lexer.js';
+import { ASTNode } from './parser.js';
+import { EvaluationContext } from './evaluator.js';
+export { Token, TokenType, LexerError } from './lexer.js';
+export { ASTNode, ASTNodeType, BinaryExpressionNode, UnaryExpressionNode, ComparisonExpressionNode, InExpressionNode, LikeExpressionNode, IdentifierNode, LiteralNode, LiteralValue, ArrayExpressionNode, ParserError, } from './parser.js';
+export { EvaluationContext, EvaluatorError, resolvePath } from './evaluator.js';
+export { tokenize } from './lexer.js';
+export { parse } from './parser.js';
+export { evaluate } from './evaluator.js';
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+    /** Error message */
+    message: string;
+    /** Position in the expression where the error occurred */
+    position?: number;
+    /** The offending token or character */
+    token?: string;
+}
+/**
+ * Result of validating an expression
+ */
+export interface ValidationResult {
+    /** Whether the expression is valid */
+    valid: boolean;
+    /** Error details if invalid */
+    error?: ValidationError;
+    /** The AST if valid */
+    ast?: ASTNode;
+}
+/**
+ * Compiled expression for efficient repeated evaluation
+ */
+export interface CompiledExpression {
+    /** The original expression string */
+    expression: string;
+    /** The parsed AST */
+    ast: ASTNode;
+    /** Tokens from lexing */
+    tokens: Token[];
+    /**
+     * Evaluate the expression against a context
+     * @param context - The context object to evaluate against
+     * @returns Boolean result of the evaluation
+     */
+    evaluate(context: EvaluationContext): boolean;
+}
+/**
+ * Expression Engine combining lexer, parser, and evaluator
+ *
+ * Provides a high-level API for working with governance expressions.
+ *
+ * @example
+ * ```ts
+ * const engine = new ExpressionEngine();
+ *
+ * // Validate an expression
+ * const result = engine.validate("intent.action == 'read'");
+ * if (result.valid) {
+ *   console.log('Expression is valid');
+ * }
+ *
+ * // Compile for repeated evaluation
+ * const compiled = engine.compile("risk.score > 50 AND role IN ['admin', 'power-user']");
+ *
+ * // Evaluate against multiple contexts
+ * compiled.evaluate({ risk: { score: 75 }, role: 'admin' }); // true
+ * compiled.evaluate({ risk: { score: 30 }, role: 'user' });  // false
+ *
+ * // One-shot evaluation
+ * const allowed = engine.evaluate("trust.level >= 3", { trust: { level: 4 } }); // true
+ * ```
+ */
+export declare class ExpressionEngine {
+    /**
+     * Compile an expression for efficient repeated evaluation
+     *
+     * @param expression - The expression string to compile
+     * @returns A compiled expression object
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     * const compiled = engine.compile("intent.action == 'read'");
+     *
+     * // Use multiple times
+     * compiled.evaluate({ intent: { action: 'read' } }); // true
+     * compiled.evaluate({ intent: { action: 'write' } }); // false
+     * ```
+     */
+    compile(expression: string): CompiledExpression;
+    /**
+     * Evaluate an expression against a context in one step
+     *
+     * For expressions that will be evaluated multiple times, consider using
+     * `compile()` instead for better performance.
+     *
+     * @param expression - The expression string to evaluate
+     * @param context - The context object to evaluate against
+     * @returns Boolean result of the evaluation
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     * @throws EvaluatorError if evaluation fails
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     *
+     * const result = engine.evaluate(
+     *   "user.role == 'admin' OR trust.score >= 800",
+     *   { user: { role: 'user' }, trust: { score: 850 } }
+     * );
+     * console.log(result); // true
+     * ```
+     */
+    evaluate(expression: string, context: EvaluationContext): boolean;
+    /**
+     * Validate an expression without evaluating it
+     *
+     * This method catches all errors during lexing and parsing and returns
+     * a structured validation result instead of throwing.
+     *
+     * @param expression - The expression string to validate
+     * @returns Validation result with error details if invalid
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     *
+     * // Valid expression
+     * const valid = engine.validate("intent.action == 'read'");
+     * console.log(valid.valid); // true
+     * console.log(valid.ast); // AST node
+     *
+     * // Invalid expression
+     * const invalid = engine.validate("intent.action ==");
+     * console.log(invalid.valid); // false
+     * console.log(invalid.error?.message); // "Unexpected end of expression"
+     * ```
+     */
+    validate(expression: string): ValidationResult;
+    /**
+     * Get the tokens from an expression (useful for debugging)
+     *
+     * @param expression - The expression string to tokenize
+     * @returns Array of tokens
+     * @throws LexerError if the expression has lexical errors
+     */
+    tokenize(expression: string): Token[];
+    /**
+     * Parse an expression into an AST (useful for debugging)
+     *
+     * @param expression - The expression string to parse
+     * @returns The AST root node
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     */
+    parse(expression: string): ASTNode;
+}
+/**
+ * Default expression engine instance for convenience
+ */
+export declare const expressionEngine: ExpressionEngine;
+//# sourceMappingURL=index.d.ts.map

package/dist/common/expression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/expression/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAY,KAAK,EAAyB,MAAM,YAAY,CAAC;AACpE,OAAO,EAAS,OAAO,EAAe,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAY,iBAAiB,EAA+B,MAAM,gBAAgB,CAAC;AAG1F,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EACL,OAAO,EACP,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGhF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,+BAA+B;IAC/B,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,uBAAuB;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB;IACrB,GAAG,EAAE,OAAO,CAAC;IACb,yBAAyB;IACzB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB;IAY/C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO;IAKjE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IA0C9C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE;IAIrC;;;;;;;OAOG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CAInC;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}