chore: rename v3 types to remove Typed prefix

- Rename TypedRuleEngine to RuleEngine
- Rename TypedEntity to Entity
- Rename TypedRule to Rule
- Rename TypedFilter to Filter
- Rename TypedRuleSet to RuleSet
- Rename TypedMatchingConfig to MatchingConfig
- Update documentation and examples

Author: phr3nzy

CHANGELOG.md

@@ -33,7 +33,7 @@ import { v3 } from '@phr3nzy/rulekit';
 const { TypedRuleEngine } = v3;
 
 // After
-import { TypedRuleEngine } from '@phr3nzy/rulekit';
+import { RuleEngine } from '@phr3nzy/rulekit';
 ```
 
 Legacy v2 functionality remains available through the v2 namespace:
@@ -68,7 +68,7 @@ const { RuleEngine } = v2.ruleEngine;
 
 ### Breaking Changes
 
-- New v3 API uses different import path (`import { v3 } from '@phr3nzy/rulekit'`)
+- New v3 API is now available at root level
 - Type-safe schemas require explicit type definitions
 - Array conditions now support both element and array-level matching
 - Rule evaluation now validates against schema types
@@ -89,15 +89,14 @@ const { RuleEngine } = v2.ruleEngine;
 import { RuleEngine } from '@phr3nzy/rulekit';
 
 // After (v3)
-import { v3 } from '@phr3nzy/rulekit';
-const { TypedRuleEngine } = v3;
+import { RuleEngine, AttributeType } from '@phr3nzy/rulekit';
 ```
 
 #### 2. Define Type-Safe Schema
 
 ```typescript
-import { v3 } from '@phr3nzy/rulekit';
-const { AttributeType } = v3;
+import { AttributeType } from '@phr3nzy/rulekit';
+import type { AttributeSchema } from '@phr3nzy/rulekit';
 
 // Define your schema with type safety
 type ProductSchema = {
@@ -117,7 +116,7 @@ type ProductSchema = {
 			min: 0;
 		};
 	};
-} & v3.AttributeSchema;
+} & AttributeSchema;
 ```
 
 #### 3. Create Type-Safe Engine
@@ -144,14 +143,14 @@ const productSchema: ProductSchema = {
 };
 
 // Create type-safe engine
-const engine = new TypedRuleEngine(productSchema);
+const engine = new RuleEngine(productSchema);
 ```
 
 #### 4. Use Type-Safe Rules
 
 ```typescript
 // Rules are now type-checked
-const rules: v3.TypedRule<ProductSchema>[] = [
+const rules: Rule<ProductSchema>[] = [
 	{
 		attributes: {
 			category: { eq: 'electronics' }, // Type-safe: must be one of the enum values
@@ -161,7 +160,7 @@ const rules: v3.TypedRule<ProductSchema>[] = [
 ];
 
 // Entities are type-checked
-const entities: v3.TypedEntity<ProductSchema>[] = [
+const entities: Entity<ProductSchema>[] = [
 	{
 		id: '1',
 		name: 'Laptop',
@@ -200,14 +199,15 @@ const rule2 = {
 
 ### Backward Compatibility
 
-V2 exports are still available for backward compatibility:
+V2 exports are still available through the v2 namespace:
 
 ```typescript
-// V2 imports still work
+// Before
 import { RuleEngine } from '@phr3nzy/rulekit';
 
-// V3 recommended imports
-import { v3 } from '@phr3nzy/rulekit';
+// After
+import { v2 } from '@phr3nzy/rulekit';
+const { RuleEngine } = v2.ruleEngine;
 ```
 
 ## [2.0.2] - 2025-02-08

README.md

@@ -30,8 +30,7 @@ pnpm add @phr3nzy/rulekit
 ## Quick Start (v3)
 
 ```typescript
-import { v3 } from '@phr3nzy/rulekit';
-const { AttributeType, TypedRuleEngine } = v3;
+import { AttributeType, RuleEngine } from '@phr3nzy/rulekit';
 
 // 1. Define your schema
 type ProductSchema = {
@@ -59,7 +58,7 @@ type ProductSchema = {
 			required: false;
 		};
 	};
-} & v3.AttributeSchema;
+} & AttributeSchema;
 
 // 2. Create schema instance
 const productSchema: ProductSchema = {
@@ -90,10 +89,10 @@ const productSchema: ProductSchema = {
 };
 
 // 3. Create engine
-const engine = new TypedRuleEngine(productSchema);
+const engine = new RuleEngine(productSchema);
 
 // 4. Define entities
-const entities: v3.TypedEntity<ProductSchema>[] = [
+const entities: Entity<ProductSchema>[] = [
 	{
 		id: '1',
 		name: 'Gaming Laptop',
@@ -117,7 +116,7 @@ const entities: v3.TypedEntity<ProductSchema>[] = [
 ];
 
 // 5. Define rules
-const rules: v3.TypedRule<ProductSchema>[] = [
+const rules: Rule<ProductSchema>[] = [
 	{
 		and: [
 			{
@@ -145,32 +144,32 @@ console.log(matches); // [{ id: '1', name: 'Gaming Laptop', ... }]
 ### Type-Safe Schema Definition
 
 ```typescript
-import { v3 } from '@phr3nzy/rulekit';
+import { AttributeType } from '@phr3nzy/rulekit';
 
 type UserSchema = {
 	role: {
-		type: typeof v3.AttributeType.ENUM;
+		type: typeof AttributeType.ENUM;
 		validation: {
-			type: typeof v3.AttributeType.ENUM;
+			type: typeof AttributeType.ENUM;
 			required: true;
 			enum: ['admin', 'user', 'guest'];
 		};
 	};
 	permissions: {
-		type: typeof v3.AttributeType.ARRAY;
+		type: typeof AttributeType.ARRAY;
 		validation: {
-			type: typeof v3.AttributeType.ARRAY;
-			arrayType: typeof v3.AttributeType.STRING;
+			type: typeof AttributeType.ARRAY;
+			arrayType: typeof AttributeType.STRING;
 			required: true;
 		};
 	};
-} & v3.AttributeSchema;
+} & AttributeSchema;
 ```
 
 ### Complex Rule Combinations
 
 ```typescript
-const rules: v3.TypedRule<UserSchema>[] = [
+const rules: Rule<UserSchema>[] = [
 	{
 		or: [
 			{
@@ -216,7 +215,7 @@ const rule2 = {
 
 ```typescript
 // Engine automatically optimizes batch size based on rule complexity
-const engine = new v3.TypedRuleEngine(schema, {
+const engine = new RuleEngine(schema, {
 	maxBatchSize: 1000, // Optional: customize batch size
 });
 

src/v3/engine/rule-engine.ts

@@ -3,25 +3,25 @@
  * Provides type-safe rule evaluation and matching
  */
 
-import type { AttributeSchema, TypedEntity, TypedRule } from '../types/schema';
+import type { AttributeSchema, Entity, Rule } from '../types/schema';
 import { isValidSchemaObject } from '../types/schema';
 
 /**
- * Configuration interface for the TypedRuleEngine
+ * Configuration interface for the RuleEngine
  */
-interface TypedRuleEngineConfig {
+interface RuleEngineConfig {
 	maxBatchSize?: number;
 }
 
 /**
  * Enhanced rule engine with generic type support
  */
-export class TypedRuleEngine<TSchema extends AttributeSchema> {
-	private readonly config: Required<TypedRuleEngineConfig>;
+export class RuleEngine<TSchema extends AttributeSchema> {
+	private readonly config: Required<RuleEngineConfig>;
 
 	constructor(
 		private readonly schema: TSchema,
-		config?: Partial<TypedRuleEngineConfig>,
+		config?: Partial<RuleEngineConfig>,
 	) {
 		this.config = {
 			maxBatchSize: 1000,
@@ -32,7 +32,7 @@ export class TypedRuleEngine<TSchema extends AttributeSchema> {
 	/**
 	 * Evaluates a single rule against an entity
 	 */
-	private evaluateRule(entity: TypedEntity<TSchema>, rule: TypedRule<TSchema>): boolean {
+	private evaluateRule(entity: Entity<TSchema>, rule: Rule<TSchema>): boolean {
 		// Validate entity against schema
 		if (!isValidSchemaObject(entity.attributes, this.schema)) {
 			return false;
@@ -94,15 +94,15 @@ export class TypedRuleEngine<TSchema extends AttributeSchema> {
 	/**
 	 * Splits entities into optimal batch sizes based on complexity
 	 */
-	private getBatchSize(entities: TypedEntity<TSchema>[], rules: TypedRule<TSchema>[]): number {
+	private getBatchSize(entities: Entity<TSchema>[], rules: Rule<TSchema>[]): number {
 		// Start with configured max batch size
 		const entityCount = entities.length;
 		let batchSize = this.config.maxBatchSize;
 
 		// Adjust based on rule complexity
 		const ruleComplexity = rules.reduce((complexity, rule) => {
 			// Count number of conditions in rule
-			const countConditions = (r: TypedRule<TSchema>): number => {
+			const countConditions = (r: Rule<TSchema>): number => {
 				let count = 0;
 				if (r.and) count += r.and.reduce((sum, subRule) => sum + countConditions(subRule), 0);
 				if (r.or) count += r.or.reduce((sum, subRule) => sum + countConditions(subRule), 0);
@@ -123,7 +123,7 @@ export class TypedRuleEngine<TSchema extends AttributeSchema> {
 	/**
 	 * Processes entities in optimally-sized batches
 	 */
-	private processBatch(entities: TypedEntity<TSchema>[], rules: TypedRule<TSchema>[]): boolean[] {
+	private processBatch(entities: Entity<TSchema>[], rules: Rule<TSchema>[]): boolean[] {
 		const batchSize = this.getBatchSize(entities, rules);
 		const results = new Array(entities.length);
 		const batches = Math.ceil(entities.length / batchSize);
@@ -153,10 +153,7 @@ export class TypedRuleEngine<TSchema extends AttributeSchema> {
 	/**
 	 * Finds entities that satisfy all provided 'from' rules
 	 */
-	findMatchingFrom(
-		entities: TypedEntity<TSchema>[],
-		rules: TypedRule<TSchema>[],
-	): TypedEntity<TSchema>[] {
+	findMatchingFrom(entities: Entity<TSchema>[], rules: Rule<TSchema>[]): Entity<TSchema>[] {
 		const results = this.processBatch(entities, rules);
 		return entities.filter((_, index) => results[index]);
 	}
@@ -165,10 +162,10 @@ export class TypedRuleEngine<TSchema extends AttributeSchema> {
 	 * Finds target entities that can be matched with source entities based on 'to' rules
 	 */
 	findMatchingTo(
-		fromEntities: TypedEntity<TSchema>[],
-		toRules: TypedRule<TSchema>[],
-		allEntities: TypedEntity<TSchema>[],
-	): TypedEntity<TSchema>[] {
+		fromEntities: Entity<TSchema>[],
+		toRules: Rule<TSchema>[],
+		allEntities: Entity<TSchema>[],
+	): Entity<TSchema>[] {
 		// First, filter out 'from' entities from all entities
 		const candidateEntities = allEntities.filter(
 			entity => !fromEntities.some(from => from.id === entity.id),