@the-trybe/formula-engine 1.0.0

package/dist/dependency-graph.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyGraphBuilder = exports.DependencyGraph = void 0;
+const dependency_extractor_1 = require("./dependency-extractor");
+const errors_1 = require("./errors");
+class DependencyGraph {
+    constructor() {
+        this.nodes = new Set();
+        this.edges = new Map();
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(id) {
+        this.nodes.add(id);
+        if (!this.edges.has(id)) {
+            this.edges.set(id, new Set());
+        }
+    }
+    /**
+     * Add an edge from source to target (source depends on target)
+     */
+    addEdge(source, target) {
+        this.addNode(source);
+        this.addNode(target);
+        this.edges.get(source).add(target);
+    }
+    /**
+     * Check if the graph has any cycles
+     */
+    hasCycles() {
+        try {
+            this.topologicalSort();
+            return false;
+        }
+        catch (error) {
+            return error instanceof errors_1.CircularDependencyError;
+        }
+    }
+    /**
+     * Get all root nodes (nodes with no dependencies)
+     */
+    getRoots() {
+        const roots = new Set();
+        for (const node of this.nodes) {
+            const deps = this.edges.get(node) || new Set();
+            if (deps.size === 0) {
+                roots.add(node);
+            }
+        }
+        return roots;
+    }
+    /**
+     * Get all nodes that depend on the given node
+     */
+    getDependents(nodeId) {
+        const dependents = new Set();
+        for (const [node, deps] of this.edges) {
+            if (deps.has(nodeId)) {
+                dependents.add(node);
+            }
+        }
+        return dependents;
+    }
+    /**
+     * Get direct dependencies of a node
+     */
+    getDependencies(nodeId) {
+        return this.edges.get(nodeId) || new Set();
+    }
+    /**
+     * Get all transitive dependencies of a node
+     */
+    getTransitiveDependencies(nodeId) {
+        const visited = new Set();
+        const result = new Set();
+        this.collectTransitiveDependencies(nodeId, visited, result);
+        result.delete(nodeId); // Don't include the node itself
+        return result;
+    }
+    collectTransitiveDependencies(nodeId, visited, result) {
+        if (visited.has(nodeId)) {
+            return;
+        }
+        visited.add(nodeId);
+        const deps = this.edges.get(nodeId);
+        if (deps) {
+            for (const dep of deps) {
+                result.add(dep);
+                this.collectTransitiveDependencies(dep, visited, result);
+            }
+        }
+    }
+    /**
+     * Perform topological sort using Kahn's algorithm
+     * Returns nodes in evaluation order (dependencies first)
+     * Throws CircularDependencyError if a cycle is detected
+     */
+    topologicalSort() {
+        // Calculate in-degree for each node
+        const inDegree = new Map();
+        for (const node of this.nodes) {
+            inDegree.set(node, 0);
+        }
+        // Count incoming edges for each node
+        for (const [, deps] of this.edges) {
+            for (const dep of deps) {
+                if (this.nodes.has(dep)) {
+                    // We need to count how many nodes depend on this one
+                    // This is actually reverse - we need dependents, not dependencies
+                }
+            }
+        }
+        // Actually, we need to build a reverse graph for proper topological sort
+        // edges: node -> dependencies means we need to evaluate dependencies first
+        // So the "in-degree" should count how many times a node is depended upon
+        const dependents = new Map();
+        for (const node of this.nodes) {
+            dependents.set(node, new Set());
+        }
+        for (const [node, deps] of this.edges) {
+            for (const dep of deps) {
+                if (dependents.has(dep)) {
+                    dependents.get(dep).add(node);
+                }
+            }
+        }
+        // Calculate in-degree (number of dependencies)
+        for (const [node, deps] of this.edges) {
+            // Only count dependencies that are actual nodes in our graph
+            const validDeps = [...deps].filter(d => this.nodes.has(d));
+            inDegree.set(node, validDeps.length);
+        }
+        // Start with nodes that have no dependencies
+        const queue = [];
+        for (const [node, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(node);
+            }
+        }
+        const result = [];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (visited.has(node))
+                continue;
+            visited.add(node);
+            result.push(node);
+            // For each node that depends on this one, decrease its in-degree
+            const deps = dependents.get(node) || new Set();
+            for (const dependent of deps) {
+                const newDegree = (inDegree.get(dependent) || 0) - 1;
+                inDegree.set(dependent, newDegree);
+                if (newDegree === 0 && !visited.has(dependent)) {
+                    queue.push(dependent);
+                }
+            }
+        }
+        // Check if all nodes were visited
+        if (result.length !== this.nodes.size) {
+            // There's a cycle - find it
+            const cycle = this.findCycle();
+            throw new errors_1.CircularDependencyError(cycle, [...this.nodes].filter(n => !visited.has(n)));
+        }
+        return result;
+    }
+    /**
+     * Find a cycle in the graph using DFS
+     */
+    findCycle() {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const deps = this.edges.get(node) || new Set();
+            for (const dep of deps) {
+                if (!this.nodes.has(dep))
+                    continue;
+                if (!visited.has(dep)) {
+                    const cycle = dfs(dep);
+                    if (cycle)
+                        return cycle;
+                }
+                else if (recursionStack.has(dep)) {
+                    // Found a cycle - extract it from the path
+                    const cycleStart = path.indexOf(dep);
+                    const cycle = path.slice(cycleStart);
+                    cycle.push(dep); // Close the cycle
+                    return cycle;
+                }
+            }
+            path.pop();
+            recursionStack.delete(node);
+            return null;
+        };
+        for (const node of this.nodes) {
+            if (!visited.has(node)) {
+                const cycle = dfs(node);
+                if (cycle)
+                    return cycle;
+            }
+        }
+        return [];
+    }
+}
+exports.DependencyGraph = DependencyGraph;
+/**
+ * Build a dependency graph from formula definitions
+ */
+class DependencyGraphBuilder {
+    constructor() {
+        this.extractor = new dependency_extractor_1.DependencyExtractor();
+    }
+    /**
+     * Build a dependency graph from formula definitions
+     */
+    build(formulas) {
+        const graph = new DependencyGraph();
+        // Create a map of formula IDs for quick lookup
+        const formulaIds = new Set(formulas.map(f => f.id));
+        // Add all formula IDs as nodes
+        for (const formula of formulas) {
+            graph.addNode(formula.id);
+        }
+        // Extract dependencies and add edges
+        for (const formula of formulas) {
+            const deps = formula.dependencies
+                ? new Set(formula.dependencies)
+                : this.extractor.extract(formula.expression);
+            for (const dep of deps) {
+                // Only add edges for dependencies that are other formulas
+                // (not external variables)
+                if (formulaIds.has(dep)) {
+                    graph.addEdge(formula.id, dep);
+                }
+            }
+        }
+        return graph;
+    }
+    /**
+     * Get the evaluation order for a set of formulas
+     */
+    getEvaluationOrder(formulas) {
+        const graph = this.build(formulas);
+        return graph.topologicalSort();
+    }
+}
+exports.DependencyGraphBuilder = DependencyGraphBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-graph.js","sourceRoot":"","sources":["../src/dependency-graph.ts"],"names":[],"mappings":"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","sourcesContent":["import { DependencyGraph as IDependencyGraph, FormulaDefinition } from './types';\nimport { DependencyExtractor } from './dependency-extractor';\nimport { CircularDependencyError } from './errors';\n\nexport class DependencyGraph implements IDependencyGraph {\n  nodes: Set<string>;\n  edges: Map<string, Set<string>>;\n\n  constructor() {\n    this.nodes = new Set();\n    this.edges = new Map();\n  }\n\n  /**\n   * Add a node to the graph\n   */\n  addNode(id: string): void {\n    this.nodes.add(id);\n    if (!this.edges.has(id)) {\n      this.edges.set(id, new Set());\n    }\n  }\n\n  /**\n   * Add an edge from source to target (source depends on target)\n   */\n  addEdge(source: string, target: string): void {\n    this.addNode(source);\n    this.addNode(target);\n    this.edges.get(source)!.add(target);\n  }\n\n  /**\n   * Check if the graph has any cycles\n   */\n  hasCycles(): boolean {\n    try {\n      this.topologicalSort();\n      return false;\n    } catch (error) {\n      return error instanceof CircularDependencyError;\n    }\n  }\n\n  /**\n   * Get all root nodes (nodes with no dependencies)\n   */\n  getRoots(): Set<string> {\n    const roots = new Set<string>();\n    for (const node of this.nodes) {\n      const deps = this.edges.get(node) || new Set();\n      if (deps.size === 0) {\n        roots.add(node);\n      }\n    }\n    return roots;\n  }\n\n  /**\n   * Get all nodes that depend on the given node\n   */\n  getDependents(nodeId: string): Set<string> {\n    const dependents = new Set<string>();\n    for (const [node, deps] of this.edges) {\n      if (deps.has(nodeId)) {\n        dependents.add(node);\n      }\n    }\n    return dependents;\n  }\n\n  /**\n   * Get direct dependencies of a node\n   */\n  getDependencies(nodeId: string): Set<string> {\n    return this.edges.get(nodeId) || new Set();\n  }\n\n  /**\n   * Get all transitive dependencies of a node\n   */\n  getTransitiveDependencies(nodeId: string): Set<string> {\n    const visited = new Set<string>();\n    const result = new Set<string>();\n    this.collectTransitiveDependencies(nodeId, visited, result);\n    result.delete(nodeId); // Don't include the node itself\n    return result;\n  }\n\n  private collectTransitiveDependencies(\n    nodeId: string,\n    visited: Set<string>,\n    result: Set<string>\n  ): void {\n    if (visited.has(nodeId)) {\n      return;\n    }\n    visited.add(nodeId);\n\n    const deps = this.edges.get(nodeId);\n    if (deps) {\n      for (const dep of deps) {\n        result.add(dep);\n        this.collectTransitiveDependencies(dep, visited, result);\n      }\n    }\n  }\n\n  /**\n   * Perform topological sort using Kahn's algorithm\n   * Returns nodes in evaluation order (dependencies first)\n   * Throws CircularDependencyError if a cycle is detected\n   */\n  topologicalSort(): string[] {\n    // Calculate in-degree for each node\n    const inDegree = new Map<string, number>();\n    for (const node of this.nodes) {\n      inDegree.set(node, 0);\n    }\n\n    // Count incoming edges for each node\n    for (const [, deps] of this.edges) {\n      for (const dep of deps) {\n        if (this.nodes.has(dep)) {\n          // We need to count how many nodes depend on this one\n          // This is actually reverse - we need dependents, not dependencies\n        }\n      }\n    }\n\n    // Actually, we need to build a reverse graph for proper topological sort\n    // edges: node -> dependencies means we need to evaluate dependencies first\n    // So the \"in-degree\" should count how many times a node is depended upon\n\n    const dependents = new Map<string, Set<string>>();\n    for (const node of this.nodes) {\n      dependents.set(node, new Set());\n    }\n\n    for (const [node, deps] of this.edges) {\n      for (const dep of deps) {\n        if (dependents.has(dep)) {\n          dependents.get(dep)!.add(node);\n        }\n      }\n    }\n\n    // Calculate in-degree (number of dependencies)\n    for (const [node, deps] of this.edges) {\n      // Only count dependencies that are actual nodes in our graph\n      const validDeps = [...deps].filter(d => this.nodes.has(d));\n      inDegree.set(node, validDeps.length);\n    }\n\n    // Start with nodes that have no dependencies\n    const queue: string[] = [];\n    for (const [node, degree] of inDegree) {\n      if (degree === 0) {\n        queue.push(node);\n      }\n    }\n\n    const result: string[] = [];\n    const visited = new Set<string>();\n\n    while (queue.length > 0) {\n      const node = queue.shift()!;\n      if (visited.has(node)) continue;\n\n      visited.add(node);\n      result.push(node);\n\n      // For each node that depends on this one, decrease its in-degree\n      const deps = dependents.get(node) || new Set();\n      for (const dependent of deps) {\n        const newDegree = (inDegree.get(dependent) || 0) - 1;\n        inDegree.set(dependent, newDegree);\n        if (newDegree === 0 && !visited.has(dependent)) {\n          queue.push(dependent);\n        }\n      }\n    }\n\n    // Check if all nodes were visited\n    if (result.length !== this.nodes.size) {\n      // There's a cycle - find it\n      const cycle = this.findCycle();\n      throw new CircularDependencyError(cycle, [...this.nodes].filter(n => !visited.has(n)));\n    }\n\n    return result;\n  }\n\n  /**\n   * Find a cycle in the graph using DFS\n   */\n  private findCycle(): string[] {\n    const visited = new Set<string>();\n    const recursionStack = new Set<string>();\n    const path: string[] = [];\n\n    const dfs = (node: string): string[] | null => {\n      visited.add(node);\n      recursionStack.add(node);\n      path.push(node);\n\n      const deps = this.edges.get(node) || new Set();\n      for (const dep of deps) {\n        if (!this.nodes.has(dep)) continue;\n\n        if (!visited.has(dep)) {\n          const cycle = dfs(dep);\n          if (cycle) return cycle;\n        } else if (recursionStack.has(dep)) {\n          // Found a cycle - extract it from the path\n          const cycleStart = path.indexOf(dep);\n          const cycle = path.slice(cycleStart);\n          cycle.push(dep); // Close the cycle\n          return cycle;\n        }\n      }\n\n      path.pop();\n      recursionStack.delete(node);\n      return null;\n    };\n\n    for (const node of this.nodes) {\n      if (!visited.has(node)) {\n        const cycle = dfs(node);\n        if (cycle) return cycle;\n      }\n    }\n\n    return [];\n  }\n}\n\n/**\n * Build a dependency graph from formula definitions\n */\nexport class DependencyGraphBuilder {\n  private extractor: DependencyExtractor;\n\n  constructor() {\n    this.extractor = new DependencyExtractor();\n  }\n\n  /**\n   * Build a dependency graph from formula definitions\n   */\n  build(formulas: FormulaDefinition[]): DependencyGraph {\n    const graph = new DependencyGraph();\n\n    // Create a map of formula IDs for quick lookup\n    const formulaIds = new Set(formulas.map(f => f.id));\n\n    // Add all formula IDs as nodes\n    for (const formula of formulas) {\n      graph.addNode(formula.id);\n    }\n\n    // Extract dependencies and add edges\n    for (const formula of formulas) {\n      const deps = formula.dependencies\n        ? new Set(formula.dependencies)\n        : this.extractor.extract(formula.expression);\n\n      for (const dep of deps) {\n        // Only add edges for dependencies that are other formulas\n        // (not external variables)\n        if (formulaIds.has(dep)) {\n          graph.addEdge(formula.id, dep);\n        }\n      }\n    }\n\n    return graph;\n  }\n\n  /**\n   * Get the evaluation order for a set of formulas\n   */\n  getEvaluationOrder(formulas: FormulaDefinition[]): string[] {\n    const graph = this.build(formulas);\n    return graph.topologicalSort();\n  }\n}\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,161 @@
+import { ValueType } from './types';
+export type ErrorCategory = 'PARSE' | 'VALIDATION' | 'EVALUATION' | 'CONFIGURATION';
+export declare abstract class FormulaEngineError extends Error {
+    abstract readonly code: string;
+    abstract readonly category: ErrorCategory;
+    constructor(message: string);
+}
+export declare class SyntaxError extends FormulaEngineError {
+    position: number;
+    line: number;
+    column: number;
+    expression: string;
+    readonly code = "PARSE_SYNTAX_ERROR";
+    readonly category: ErrorCategory;
+    constructor(message: string, position: number, line: number, column: number, expression: string);
+}
+export declare class UnexpectedTokenError extends FormulaEngineError {
+    token: string;
+    expected: string[];
+    position: number;
+    readonly code = "PARSE_UNEXPECTED_TOKEN";
+    readonly category: ErrorCategory;
+    constructor(token: string, expected: string[], position: number);
+}
+export declare class UnterminatedStringError extends FormulaEngineError {
+    readonly code = "PARSE_UNTERMINATED_STRING";
+    readonly category: ErrorCategory;
+    constructor(position: number);
+}
+export declare class InvalidNumberError extends FormulaEngineError {
+    readonly code = "PARSE_INVALID_NUMBER";
+    readonly category: ErrorCategory;
+    constructor(value: string, position: number);
+}
+export declare class CircularDependencyError extends FormulaEngineError {
+    cycle: string[];
+    involvedFormulas: string[];
+    readonly code = "VALIDATION_CIRCULAR_DEPENDENCY";
+    readonly category: ErrorCategory;
+    constructor(cycle: string[], involvedFormulas: string[]);
+}
+export declare class UndefinedVariableError extends FormulaEngineError {
+    variableName: string;
+    expression: string;
+    readonly code = "VALIDATION_UNDEFINED_VARIABLE";
+    readonly category: ErrorCategory;
+    constructor(variableName: string, expression: string);
+}
+export declare class UndefinedFunctionError extends FormulaEngineError {
+    functionName: string;
+    readonly code = "VALIDATION_UNDEFINED_FUNCTION";
+    readonly category: ErrorCategory;
+    constructor(functionName: string);
+}
+export declare class DuplicateFormulaError extends FormulaEngineError {
+    formulaId: string;
+    readonly code = "VALIDATION_DUPLICATE_FORMULA";
+    readonly category: ErrorCategory;
+    constructor(formulaId: string);
+}
+export declare class DivisionByZeroError extends FormulaEngineError {
+    readonly code = "EVAL_DIVISION_BY_ZERO";
+    readonly category: ErrorCategory;
+    constructor();
+}
+export declare class TypeMismatchError extends FormulaEngineError {
+    expected: ValueType | ValueType[] | string;
+    actual: ValueType | string;
+    context: string;
+    readonly code = "EVAL_TYPE_MISMATCH";
+    readonly category: ErrorCategory;
+    constructor(expected: ValueType | ValueType[] | string, actual: ValueType | string, context: string);
+}
+export declare class ArgumentCountError extends FormulaEngineError {
+    functionName: string;
+    expected: {
+        min: number;
+        max: number;
+    };
+    actual: number;
+    readonly code = "EVAL_ARGUMENT_COUNT";
+    readonly category: ErrorCategory;
+    constructor(functionName: string, expected: {
+        min: number;
+        max: number;
+    }, actual: number);
+}
+export declare class InvalidOperationError extends FormulaEngineError {
+    operator: string;
+    operandTypes: string[];
+    readonly code = "EVAL_INVALID_OPERATION";
+    readonly category: ErrorCategory;
+    constructor(operator: string, operandTypes: string[]);
+}
+export declare class PropertyAccessError extends FormulaEngineError {
+    property: string;
+    objectType: string;
+    readonly code = "EVAL_PROPERTY_ACCESS";
+    readonly category: ErrorCategory;
+    constructor(property: string, objectType: string);
+}
+export declare class IndexAccessError extends FormulaEngineError {
+    index: unknown;
+    objectType: string;
+    readonly code = "EVAL_INDEX_ACCESS";
+    readonly category: ErrorCategory;
+    constructor(index: unknown, objectType: string);
+}
+export declare class DecimalError extends FormulaEngineError {
+    readonly code: string;
+    readonly category: ErrorCategory;
+    constructor(message: string);
+}
+export declare class DecimalOverflowError extends DecimalError {
+    value: string;
+    maxExponent: number;
+    readonly code: string;
+    constructor(value: string, maxExponent: number);
+}
+export declare class DecimalUnderflowError extends DecimalError {
+    value: string;
+    minExponent: number;
+    readonly code: string;
+    constructor(value: string, minExponent: number);
+}
+export declare class DecimalDivisionByZeroError extends DecimalError {
+    readonly code: string;
+    constructor();
+}
+export declare class InvalidDecimalError extends DecimalError {
+    input: string;
+    readonly code: string;
+    constructor(input: string);
+}
+export declare class ConfigurationError extends FormulaEngineError {
+    readonly code = "CONFIGURATION_ERROR";
+    readonly category: ErrorCategory;
+    constructor(message: string);
+}
+export declare class SecurityError extends FormulaEngineError {
+    readonly code: string;
+    readonly category: ErrorCategory;
+    constructor(message: string);
+}
+export declare class MaxIterationsError extends SecurityError {
+    readonly code: string;
+    constructor(limit: number);
+}
+export declare class MaxRecursionError extends SecurityError {
+    readonly code: string;
+    constructor(limit: number);
+}
+export declare class MaxExpressionLengthError extends SecurityError {
+    readonly code: string;
+    constructor(length: number, limit: number);
+}
+export declare class GeneralFormulaError extends FormulaEngineError {
+    readonly code: string;
+    readonly category: ErrorCategory;
+    constructor(message: string);
+}