@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/expressions/utils.test.ts

@@ -1,346 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getProperties } from './utils';
-import { PropertyExpression, ComparatorExpression, OperatorExpression, ValueExpression, EmptyExpression } from './types';
-import { PropertyInfo } from '../schema/PropertyInfo';
-
-const createMockProperty = (name: string): PropertyInfo<any> => ({
-    name,
-    type: 'string',
-    isNullable: false,
-    isOptional: false,
-    isKey: false,
-    isIdentity: false,
-    isReadonly: false,
-    isUnmapped: false,
-    isDistinct: false,
-    indexes: [],
-    injected: null,
-    defaultValue: null,
-    valueSerializer: null,
-    valueDeserializer: null,
-    functionBody: null,
-    children: [],
-    schema: {} as any,
-    literals: [],
-    getPathArray: () => [name],
-    getParentPathArray: () => [] as any[],
-    getValue: () => undefined as any,
-    setValue: () => { },
-    getSelectrorPath: () => name,
-    getAssignmentPath: () => name,
-    get level() { return 0; },
-    get hasNullableParents() { return false; },
-    get hasIdentityChildren() { return false; },
-    get id() { return name; },
-    _getPropertyChain: () => [] as any[],
-    _needsOptionalChaining: () => false,
-    _resolvePathArray: () => [name]
-} as unknown as PropertyInfo<any>);
-
-describe('getProperties', () => {
-    it('should extract properties from a simple property expression', () => {
-        const property = createMockProperty('name');
-        const expression = new PropertyExpression({ property });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should extract properties from a comparator expression with property on left', () => {
-        const property = createMockProperty('age');
-        const expression = new ComparatorExpression({
-            comparator: 'equals',
-            negated: false,
-            strict: false,
-            left: new PropertyExpression({ property }),
-            right: new ValueExpression({ value: 25 })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should extract properties from a comparator expression with property on right', () => {
-        const property = createMockProperty('score');
-        const expression = new ComparatorExpression({
-            comparator: 'greater-than',
-            negated: false,
-            strict: false,
-            left: new ValueExpression({ value: 100 }),
-            right: new PropertyExpression({ property })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should extract properties from a comparator expression with properties on both sides', () => {
-        const leftProperty = createMockProperty('x');
-        const rightProperty = createMockProperty('y');
-        const expression = new ComparatorExpression({
-            comparator: 'equals',
-            negated: false,
-            strict: false,
-            left: new PropertyExpression({ property: leftProperty }),
-            right: new PropertyExpression({ property: rightProperty })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(2);
-        expect(result).toContain(leftProperty);
-        expect(result).toContain(rightProperty);
-    });
-
-    it('should extract properties from an operator expression with two properties', () => {
-        const leftProperty = createMockProperty('isActive');
-        const rightProperty = createMockProperty('isVerified');
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property: leftProperty }),
-            right: new PropertyExpression({ property: rightProperty })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(2);
-        expect(result).toContain(leftProperty);
-        expect(result).toContain(rightProperty);
-    });
-
-    it('should extract properties from a complex nested expression', () => {
-        const prop1 = createMockProperty('name');
-        const prop2 = createMockProperty('age');
-        const prop3 = createMockProperty('email');
-
-        const innerExpression = new OperatorExpression({
-            operator: '||',
-            left: new PropertyExpression({ property: prop2 }),
-            right: new PropertyExpression({ property: prop3 })
-        });
-
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property: prop1 }),
-            right: innerExpression
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(3);
-        expect(result).toContain(prop1);
-        expect(result).toContain(prop2);
-        expect(result).toContain(prop3);
-    });
-
-    it('should extract properties from a deeply nested expression', () => {
-        const prop1 = createMockProperty('level1');
-        const prop2 = createMockProperty('level2');
-        const prop3 = createMockProperty('level3');
-
-        const level3Expression = new PropertyExpression({ property: prop3 });
-
-        const level2Expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property: prop2 }),
-            right: level3Expression
-        });
-
-        const level1Expression = new OperatorExpression({
-            operator: '||',
-            left: new PropertyExpression({ property: prop1 }),
-            right: level2Expression
-        });
-
-        const result = getProperties(level1Expression);
-
-        expect(result).toHaveLength(3);
-        expect(result).toContain(prop1);
-        expect(result).toContain(prop2);
-        expect(result).toContain(prop3);
-    });
-
-    it('should handle expressions with duplicate properties', () => {
-        const property = createMockProperty('status');
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property }),
-            right: new PropertyExpression({ property })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(2);
-        expect(result[0]).toBe(property);
-        expect(result[1]).toBe(property);
-    });
-
-    it('should handle expressions with only value expressions', () => {
-        const expression = new ValueExpression({ value: 'test' });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(0);
-    });
-
-    it('should handle expressions with mixed property and value expressions', () => {
-        const property = createMockProperty('category');
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property }),
-            right: new ValueExpression({ value: 'electronics' })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should handle expressions with null or undefined children', () => {
-        const property = createMockProperty('title');
-        const expression = new ComparatorExpression({
-            comparator: 'equals',
-            negated: false,
-            strict: false,
-            left: new PropertyExpression({ property }),
-            right: null as any
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should handle empty expression', () => {
-        const expression = new EmptyExpression();
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(0);
-    });
-
-    it('should handle complex expression with multiple operators and properties', () => {
-        const prop1 = createMockProperty('firstName');
-        const prop2 = createMockProperty('lastName');
-        const prop3 = createMockProperty('email');
-        const prop4 = createMockProperty('phone');
-
-        const leftBranch = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property: prop1 }),
-            right: new PropertyExpression({ property: prop2 })
-        });
-
-        const rightBranch = new OperatorExpression({
-            operator: '||',
-            left: new PropertyExpression({ property: prop3 }),
-            right: new PropertyExpression({ property: prop4 })
-        });
-
-        const rootExpression = new OperatorExpression({
-            operator: '&&',
-            left: leftBranch,
-            right: rightBranch
-        });
-
-        const result = getProperties(rootExpression);
-
-        expect(result).toHaveLength(4);
-        expect(result).toContain(prop1);
-        expect(result).toContain(prop2);
-        expect(result).toContain(prop3);
-        expect(result).toContain(prop4);
-    });
-
-    it('should handle a large expression tree with many properties', () => {
-        const properties = [
-            createMockProperty('prop1'),
-            createMockProperty('prop2'),
-            createMockProperty('prop3'),
-            createMockProperty('prop4'),
-            createMockProperty('prop5')
-        ];
-
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new OperatorExpression({
-                operator: '||',
-                left: new PropertyExpression({ property: properties[0] }),
-                right: new PropertyExpression({ property: properties[1] })
-            }),
-            right: new OperatorExpression({
-                operator: '&&',
-                left: new PropertyExpression({ property: properties[2] }),
-                right: new OperatorExpression({
-                    operator: '||',
-                    left: new PropertyExpression({ property: properties[3] }),
-                    right: new PropertyExpression({ property: properties[4] })
-                })
-            })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(5);
-        properties.forEach(prop => {
-            expect(result).toContain(prop);
-        });
-    });
-
-    it('should handle expressions with only non-property expressions', () => {
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new ValueExpression({ value: true }),
-            right: new ValueExpression({ value: false })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(0);
-    });
-
-    it('should handle expressions with one property and one non-property', () => {
-        const property = createMockProperty('enabled');
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property }),
-            right: new ValueExpression({ value: true })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(1);
-        expect(result[0]).toBe(property);
-    });
-
-    it('should preserve order of properties as they appear in traversal', () => {
-        const prop1 = createMockProperty('a');
-        const prop2 = createMockProperty('b');
-        const prop3 = createMockProperty('c');
-
-        const expression = new OperatorExpression({
-            operator: '&&',
-            left: new PropertyExpression({ property: prop1 }),
-            right: new OperatorExpression({
-                operator: '||',
-                left: new PropertyExpression({ property: prop2 }),
-                right: new PropertyExpression({ property: prop3 })
-            })
-        });
-
-        const result = getProperties(expression);
-
-        expect(result).toHaveLength(3);
-        expect(result[0]).toBe(prop1);
-        expect(result[1]).toBe(prop2);
-        expect(result[2]).toBe(prop3);
-    });
-}); 

package/src/expressions/utils.ts

@@ -1,59 +0,0 @@
-import { PropertyInfo } from "../schema";
-import { Expression, PropertyExpression } from "./types";
-
-/**
- * Extracts all properties referenced in an expression
- * @param expression The expression to analyze
- * @returns Array of PropertyInfo objects referenced in the expression
- */
-export function getProperties(expression: Expression): PropertyInfo<any>[] {
-    const properties: PropertyInfo<any>[] = [];
-
-    function traverse(expr: Expression) {
-        // If this is a property expression, add it to our collection
-        if (expr.type === "property") {
-            properties.push((expr as PropertyExpression).property);
-        }
-
-        // Traverse left and right expressions if they exist
-        if (expr.left) {
-            traverse(expr.left);
-        }
-        if (expr.right) {
-            traverse(expr.right);
-        }
-    }
-
-    traverse(expression);
-    return properties;
-}
-
-export function isPropertyExpression(expression: Expression): expression is PropertyExpression {
-    return expression.type === "property";
-}
-
-export function forEach(expression: Expression, callback: (expression: Expression) => boolean) {
-    function traverse(expr: Expression): boolean {
-        // Call the callback for this expression
-        // If callback returns false, stop traversing
-        if (!callback(expr)) {
-            return false;
-        }
-
-        // Traverse left and right expressions if they exist
-        if (expr.left) {
-            if (!traverse(expr.left)) {
-                return false;
-            }
-        }
-        if (expr.right) {
-            if (!traverse(expr.right)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    traverse(expression);
-}

package/src/performance/index.ts

@@ -1,26 +0,0 @@
-const measurements: Record<string, number> = {}
-
-export const now = (): number => {
-    if (typeof performance !== 'undefined' && performance.now) {
-        // Browser or modern Node.js
-        return performance.now();
-    }
-
-    // Fallback for older environments
-    return Date.now();
-}
-
-export const measure = {
-    start: (name: string): void => {
-        measurements[name] = now();
-    },
-    end: (name: string): void => {
-        const start = measurements[name];
-
-        delete measurements[name];
-
-        const delta = now() - start;
-
-        console.log(`[ROUTIER] - Performance: ${name} took ${delta}`);
-    }
-}

package/src/pipeline/SyncronousQueue.test.ts

@@ -1,269 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { SyncronousQueue, SyncronousUnitOfWork } from './SyncronousQueue';
-
-describe('SyncronousQueue', () => {
-    describe('enqueue', () => {
-        it('should add unit of work to queue and start processing', () => {
-            const queue = new SyncronousQueue();
-            const mockUnitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            queue.enqueue(mockUnitOfWork);
-
-            expect(mockUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-
-        it('should process multiple units of work in order', () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const unitOfWork1 = vi.fn((done: () => void) => {
-                executionOrder.push(1);
-                done();
-            });
-
-            const unitOfWork2 = vi.fn((done: () => void) => {
-                executionOrder.push(2);
-                done();
-            });
-
-            queue.enqueue(unitOfWork1);
-            queue.enqueue(unitOfWork2);
-
-            expect(executionOrder).toEqual([1, 2]);
-            expect(unitOfWork1).toHaveBeenCalledTimes(1);
-            expect(unitOfWork2).toHaveBeenCalledTimes(1);
-        });
-
-        it('should not start processing if already processing', () => {
-            const queue = new SyncronousQueue();
-            let doneCalled = false;
-
-            const slowUnitOfWork = vi.fn((done: () => void) => {
-                setTimeout(() => {
-                    doneCalled = true;
-                    done();
-                }, 10);
-            });
-
-            const fastUnitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            queue.enqueue(slowUnitOfWork);
-            queue.enqueue(fastUnitOfWork);
-
-            expect(slowUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(fastUnitOfWork).toHaveBeenCalledTimes(0);
-        });
-
-        it('should process next unit of work after current one completes', async () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const slowUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(1);
-                setTimeout(() => {
-                    done();
-                }, 10);
-            });
-
-            const fastUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(2);
-                done();
-            });
-
-            queue.enqueue(slowUnitOfWork);
-            queue.enqueue(fastUnitOfWork);
-
-            await new Promise(resolve => setTimeout(resolve, 20));
-
-            expect(executionOrder).toEqual([1, 2]);
-            expect(slowUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(fastUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    describe('queue behavior', () => {
-        it('should handle empty queue', () => {
-            const queue = new SyncronousQueue();
-
-            expect(() => {
-                queue.enqueue(vi.fn((done: () => void) => done()));
-            }).not.toThrow();
-        });
-
-        it('should handle unit of work that never calls done', () => {
-            const queue = new SyncronousQueue();
-            const stuckUnitOfWork = vi.fn((done: () => void) => {
-                // Never calls done
-            });
-
-            const secondUnitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            queue.enqueue(stuckUnitOfWork);
-            queue.enqueue(secondUnitOfWork);
-
-            expect(stuckUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(secondUnitOfWork).toHaveBeenCalledTimes(0);
-        });
-
-        it('should handle unit of work that calls done multiple times', () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const multiDoneUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(1);
-                done();
-                done(); // Call done multiple times
-            });
-
-            const secondUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(2);
-                done();
-            });
-
-            queue.enqueue(multiDoneUnitOfWork);
-            queue.enqueue(secondUnitOfWork);
-
-            expect(executionOrder).toEqual([1, 2]);
-            expect(multiDoneUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(secondUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-
-        it('should handle rapid enqueueing of multiple units', () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const createUnitOfWork = (id: number) => vi.fn((done: () => void) => {
-                executionOrder.push(id);
-                done();
-            });
-
-            for (let i = 1; i <= 5; i++) {
-                queue.enqueue(createUnitOfWork(i));
-            }
-
-            expect(executionOrder).toEqual([1, 2, 3, 4, 5]);
-        });
-
-        it('should handle unit of work that throws error', () => {
-            const queue = new SyncronousQueue();
-            const errorUnitOfWork = vi.fn((done: () => void) => {
-                throw new Error('Test error');
-            });
-
-            const secondUnitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            expect(() => {
-                queue.enqueue(errorUnitOfWork);
-            }).toThrow('Test error');
-
-            expect(errorUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-
-        it('should not process next unit after error', () => {
-            const queue = new SyncronousQueue();
-            const errorUnitOfWork = vi.fn((done: () => void) => {
-                throw new Error('Test error');
-            });
-
-            const secondUnitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            try {
-                queue.enqueue(errorUnitOfWork);
-            } catch (error) {
-                // Error is thrown, queue stops processing
-            }
-
-            queue.enqueue(secondUnitOfWork);
-
-            expect(errorUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(secondUnitOfWork).toHaveBeenCalledTimes(0);
-        });
-
-        it('should handle unit of work that calls done asynchronously', async () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const asyncUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(1);
-                Promise.resolve().then(() => {
-                    done();
-                });
-            });
-
-            const syncUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(2);
-                done();
-            });
-
-            queue.enqueue(asyncUnitOfWork);
-            queue.enqueue(syncUnitOfWork);
-
-            await new Promise(resolve => setTimeout(resolve, 10));
-
-            expect(executionOrder).toEqual([1, 2]);
-            expect(asyncUnitOfWork).toHaveBeenCalledTimes(1);
-            expect(syncUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle null done callback', () => {
-            const queue = new SyncronousQueue();
-            const unitOfWork = vi.fn((done: () => void) => {
-                done();
-            });
-
-            expect(() => {
-                queue.enqueue(unitOfWork);
-            }).not.toThrow();
-
-            expect(unitOfWork).toHaveBeenCalledTimes(1);
-        });
-
-        it('should handle unit of work that enqueues another unit of work', () => {
-            const queue = new SyncronousQueue();
-            const executionOrder: number[] = [];
-
-            const recursiveUnitOfWork = vi.fn((done: () => void) => {
-                executionOrder.push(1);
-                queue.enqueue(vi.fn((innerDone: () => void) => {
-                    executionOrder.push(2);
-                    innerDone();
-                }));
-                done();
-            });
-
-            queue.enqueue(recursiveUnitOfWork);
-
-            expect(executionOrder).toEqual([1, 2]);
-            expect(recursiveUnitOfWork).toHaveBeenCalledTimes(1);
-        });
-
-        it('should handle multiple rapid enqueue operations', () => {
-            const queue = new SyncronousQueue();
-            const executionCount = { count: 0 };
-
-            const unitOfWork = vi.fn((done: () => void) => {
-                executionCount.count++;
-                done();
-            });
-
-            for (let i = 0; i < 100; i++) {
-                queue.enqueue(unitOfWork);
-            }
-
-            expect(executionCount.count).toBe(100);
-            expect(unitOfWork).toHaveBeenCalledTimes(100);
-        });
-    });
-});