@routier/core 0.0.1-alpha.1

package/src/expressions/types.ts

@@ -0,0 +1,184 @@
+import { QueryOptionExecutionTarget } from "../plugins";
+import { PropertyInfo } from "../schema";
+
+export type ParsedExpression = {
+    expression: Expression;
+    // Will be memory when trying to query on an untracked computed property or on a function
+    executionTarget: QueryOptionExecutionTarget;
+}
+
+/**
+ * The base class for all expression types.
+ */
+export abstract class Expression {
+    /** The type of the expression. */
+    abstract readonly type: ExpressionType;
+    /** The left-hand side of the expression (if applicable). */
+    left?: Expression;
+    /** The right-hand side of the expression (if applicable). */
+    right?: Expression;
+
+    constructor(left?: Expression, right?: Expression) {
+        this.left = left;
+        this.right = right;
+    }
+
+    static get EMPTY() {
+        return new EmptyExpression();
+    }
+
+    static get NOT_PARSABLE() {
+        return new NotParsableExpression();
+    }
+
+    static isEmpty(expression: Expression) {
+        return expression.type === "empty" || expression instanceof EmptyExpression;
+    }
+
+    static isNotParsable(expression: Expression) {
+        return expression.type === "not-parsable" || expression instanceof NotParsableExpression;
+    }
+}
+
+export class EmptyExpression extends Expression {
+    readonly type = "empty" as const;
+}
+
+export class NotParsableExpression extends Expression {
+    readonly type = "not-parsable" as const;
+}
+
+/**
+ * A class representing a comparison operation (e.g., equals, greater-than).
+ */
+export class ComparatorExpression extends Expression {
+    /** The type of the expression (always 'comparator'). */
+    readonly type = "comparator" as const;
+    /** The comparator operation (e.g., equals, greater-than). */
+    comparator: Comparator;
+    /** Whether the comparison is negated (e.g., not equals). */
+    negated: boolean;
+    /** Whether the comparison is strict (type-sensitive). */
+    strict: boolean;
+
+    constructor(
+        options: {
+            comparator: Comparator,
+            negated: boolean,
+            strict: boolean,
+            left?: Expression,
+            right?: Expression
+        }
+    ) {
+        super(options.left, options.right);
+        this.comparator = options.comparator;
+        this.negated = options.negated;
+        this.strict = options.strict;
+    }
+}
+
+/**
+ * A class representing a logical operator (e.g., &&, ||).
+ */
+export class OperatorExpression extends Expression {
+    /** The type of the expression (always 'operator'). */
+    readonly type = "operator" as const;
+    /** The logical operator. */
+    operator: Operator;
+
+    constructor(options: { operator: Operator, left?: Expression, right?: Expression }) {
+        super(options.left, options.right);
+        this.operator = options.operator;
+    }
+}
+
+/**
+ * A class representing a property path.
+ */
+export class PropertyExpression extends Expression {
+    /** The type of the expression (always 'property'). */
+    readonly type = "property" as const;
+    /** The property info for the path. */
+    property: PropertyInfo<any>;
+    transformer: Transformer | null = null;
+    locale: string | null = null;
+
+    constructor(options: { property: PropertyInfo<any> }) {
+        super();
+        this.property = options.property;
+    }
+}
+
+/**
+ * A class representing a literal value.
+ */
+export class ValueExpression extends Expression {
+    /** The type of the expression (always 'value'). */
+    readonly type = "value" as const;
+    /** The literal value. */
+    value: unknown;
+
+    transformer: Transformer | null = null;
+    locale: string | null = null;
+
+    constructor(options: {
+        value: unknown
+    }) {
+        super();
+        this.value = options.value;
+    }
+}
+
+
+/**
+ * The set of possible expression types.
+ */
+export type ExpressionType = "operator" | "comparator" | "property" | "value" | "empty" | "not-parsable";
+
+/**
+ * Supported value transformations that can be applied to values.
+ */
+export type Transformer = "to-lower-case" | "to-upper-case";
+
+/**
+ * Supported comparator operations for expressions.
+ */
+export type Comparator =
+    | "equals"
+    | "starts-with"
+    | "includes"
+    | "ends-with"
+    | "greater-than"
+    | "greater-than-equals"
+    | "less-than"
+    | "less-than-equals";
+
+/**
+ * Supported logical operators for expressions.
+ */
+export type Operator = "&&" | "||";
+
+/**
+ * A function that filters a value of type T and returns a boolean.
+ */
+export type Filter<T extends any> = (value: T) => boolean;
+
+/**
+ * A function that filters a value of type T with additional parameters P.
+ */
+export type ParamsFilter<T extends any, P> = (payload: [T, P]) => boolean;
+
+/**
+ * A filter that can be either a simple filter or a parameterized filter.
+ */
+export type CompositeFilter<T extends any, P = never> = Filter<T> | ParamsFilter<T, P>;
+
+/**
+ * An object that can be filtered using a composite filter and optional parameters.
+ */
+export type Filterable<T extends any, P = any> = {
+    /** The filter function. */
+    filter: CompositeFilter<T, P>;
+    /** Optional parameters for the filter. */
+    params?: P;
+}

package/src/expressions/utils.test.ts

@@ -0,0 +1,346 @@
+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

@@ -0,0 +1,59 @@
+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/index.ts

@@ -0,0 +1,12 @@
+export * from './assertions';
+export * from './codegen';
+export * from './collections';
+export * from './errors';
+export * from './expressions';
+export * from './performance';
+export * from './pipeline';
+export * from './plugins';
+export * from './results';
+export * from './schema';
+export * from './types';
+export * from './utilities';

package/src/performance/index.ts

@@ -0,0 +1,26 @@
+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}`);
+    }
+}