> ## Documentation Index
> Fetch the complete documentation index at: https://crafts69guy.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Introduction
> A powerful, flexible JavaScript rule engine for dynamic business logic evaluation
## Welcome to Rule Engine JS
**Stop hardcoding business logic.** Rule Engine JS lets you define complex conditional logic as data, making your applications more flexible, maintainable, and business-friendly.
```javascript Instead of this... theme={null}
if (user.age >= 18 && user.role === 'admin' && user.permissions.includes('write')) {
return true;
}
```
```javascript Write this declarative rule theme={null}
const rule = rules.and(
rules.gte('age', 18),
rules.eq('role', 'admin'),
rules.in('write', 'permissions')
);
const result = engine.evaluateExpr(rule, user);
```
## Key Features
Lightweight with no external dependencies for minimal bundle size
Intelligent caching with LRU eviction for optimal speed
Built-in protection against prototype pollution and malicious access
Full TypeScript support with comprehensive type definitions
Track state changes with event-driven architecture
Easy custom operator registration for business-specific logic
Compare values across different data paths
Built-in performance metrics and cache statistics
## Why Choose Rule Engine JS?
Define business rules as JSON data instead of hardcoding them. Update rules without deploying code changes.
Fluent helper API makes building complex rules intuitive and readable.
Battle-tested with 500+ unit tests and >90% code coverage. Zero dependencies means fewer security
vulnerabilities.
Works with any JavaScript framework - React, Vue, Angular, Node.js, Express, and more.
## Installation
```bash npm theme={null}
npm install rule-engine-js
```
```bash yarn theme={null}
yarn add rule-engine-js
```
```bash pnpm theme={null}
pnpm add rule-engine-js
```
## Quick Example
Here's a simple example to get you started:
```javascript theme={null}
import { createRuleEngine, createRuleHelpers } from 'rule-engine-js';
// Create engine and helpers
const engine = createRuleEngine();
const rules = createRuleHelpers();
// Your data
const user = {
name: 'John Doe',
age: 28,
role: 'admin',
email: 'john@company.com',
permissions: ['read', 'write', 'delete'],
};
// Simple rule
const isAdult = rules.gte('age', 18);
console.log(engine.evaluateExpr(isAdult, user).success); // true
// Complex rule
const canAccess = rules.and(
rules.gte('age', 18),
rules.eq('role', 'admin'),
rules.validation.email('email'),
rules.in('write', 'permissions')
);
console.log(engine.evaluateExpr(canAccess, user).success); // true
```
## Core Principles
Rules are simple JSON objects that describe conditions, making them easy to store, version, and manage.
Express complex logic in a readable, maintainable format using helper functions or raw JSON.
Security features protect against common vulnerabilities like prototype pollution and malicious
data access.
Intelligent caching and optimized evaluation paths ensure fast rule execution even with complex logic.
## What's Next?
Get up and running in 5 minutes with our quickstart guide
Learn about the engine architecture and key concepts
Explore all available operators and their usage
See real-world examples and use cases
## Community and Support
View source code and contribute
Report bugs or request features
Ask questions and share ideas