@cheetah.js/orm 0.1.143 → 0.1.144

package/README.md

@@ -180,6 +180,32 @@ export class User {
 }
 ```
 
+You can also use the ORM filter syntax in `where` (with `$in`, `$or`, `$nor`, etc.):
+
+```javascript
+@Entity()
+@Index<{ User }>({
+  properties: ['email'],
+  where: {
+    isActive: true,
+    status: { $in: ['active', 'pending'] },
+  },
+})
+export class User {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  email: string;
+
+  @Property()
+  isActive: boolean;
+
+  @Property()
+  status: string;
+}
+```
+
 Note: MySQL does not support partial indexes; using `where` with the MySQL driver will throw.
 
 #### Property options

package/dist/decorators/index.decorator.d.ts

@@ -1,15 +1,17 @@
+import { FilterQuery } from "../driver/driver.interface";
 export type IndexColumnMap<T> = {
     [K in keyof T as K extends symbol ? never : K]: string;
 };
 export type IndexPredicate<T> = string | ((columns: IndexColumnMap<T>) => string);
+export type IndexWhere<T> = IndexPredicate<T> | FilterQuery<T>;
 export type IndexDefinition = {
     name: string;
     properties: string[];
-    where?: IndexPredicate<any>;
+    where?: IndexWhere<any>;
 };
 type IndexOptions<T> = {
     properties: (keyof T)[];
-    where?: IndexPredicate<T>;
+    where?: IndexWhere<T>;
 } | (keyof T)[] | undefined;
 export declare function Index<T>(options?: IndexOptions<T>): ClassDecorator & PropertyDecorator;
 export {};

package/dist/domain/entities.js

@@ -14,6 +14,7 @@ exports.EntityStorage = void 0;
 const core_1 = require("@cheetah.js/core");
 const orm_session_context_1 = require("../orm-session-context");
 const utils_1 = require("../utils");
+const index_condition_builder_1 = require("../query/index-condition-builder");
 function buildIndexColumnMap(properties, relations) {
     const map = mapPropertyColumns(properties);
     addRelationColumns(map, relations);
@@ -67,7 +68,14 @@ function resolveIndexWhere(where, columnMap) {
     if (typeof where === "string") {
         return where;
     }
-    return where(columnMap);
+    if (typeof where === "function") {
+        return where(columnMap);
+    }
+    return buildIndexWhere(where, columnMap);
+}
+function buildIndexWhere(where, columnMap) {
+    const builder = new index_condition_builder_1.IndexConditionBuilder(columnMap);
+    return builder.build(where);
 }
 let EntityStorage = EntityStorage_1 = class EntityStorage {
     constructor() {

package/dist/query/index-condition-builder.d.ts

@@ -0,0 +1,41 @@
+import { FilterQuery } from '../driver/driver.interface';
+export declare class IndexConditionBuilder<T> {
+    private columnMap;
+    private readonly OPERATORS;
+    private lastKeyNotOperator;
+    constructor(columnMap: Record<string, string>);
+    build(condition: FilterQuery<T>): string;
+    private processConditions;
+    private getEntries;
+    private processEntries;
+    private processEntry;
+    private handleScalarValue;
+    private handleObjectValue;
+    private buildLogicalOperatorCondition;
+    private buildOperatorConditions;
+    private buildOperatorCondition;
+    private buildSimpleCondition;
+    private buildInCondition;
+    private buildNotInCondition;
+    private buildLikeCondition;
+    private buildComparisonCondition;
+    private buildNestedLogicalCondition;
+    private buildNorCondition;
+    private wrapWithLogicalOperator;
+    private extractValueFromValueObject;
+    private formatValue;
+    private formatDate;
+    private isNullish;
+    private isPrimitive;
+    private formatPrimitive;
+    private formatJson;
+    private escapeString;
+    private isScalarValue;
+    private isArrayValue;
+    private isLogicalOperator;
+    private isNorOperator;
+    private extractLogicalOperator;
+    private trackLastNonOperatorKey;
+    private resolveColumnName;
+    private buildNullCondition;
+}

package/dist/query/index-condition-builder.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexConditionBuilder = void 0;
+const value_object_1 = require("../common/value-object");
+const utils_1 = require("../utils");
+class IndexConditionBuilder {
+    constructor(columnMap) {
+        this.columnMap = columnMap;
+        this.OPERATORS = [
+            '$eq',
+            '$ne',
+            '$in',
+            '$nin',
+            '$like',
+            '$gt',
+            '$gte',
+            '$lt',
+            '$lte',
+            '$and',
+            '$or',
+            '$nor',
+        ];
+        this.lastKeyNotOperator = '';
+    }
+    build(condition) {
+        const sqlParts = this.processConditions(condition);
+        if (sqlParts.length === 0) {
+            return '';
+        }
+        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+    }
+    processConditions(condition) {
+        const entries = this.getEntries(condition);
+        return this.processEntries(entries);
+    }
+    getEntries(condition) {
+        if (!condition || typeof condition !== 'object') {
+            return [];
+        }
+        return Object.entries(condition);
+    }
+    processEntries(entries) {
+        const sqlParts = [];
+        for (const [key, value] of entries) {
+            const extractedValue = this.extractValueFromValueObject(value);
+            const conditionSql = this.processEntry(key, extractedValue);
+            if (conditionSql) {
+                sqlParts.push(conditionSql);
+            }
+        }
+        return sqlParts;
+    }
+    processEntry(key, value) {
+        this.trackLastNonOperatorKey(key);
+        if (this.isScalarValue(value)) {
+            return this.handleScalarValue(key, value);
+        }
+        if (this.isArrayValue(key, value)) {
+            return this.buildInCondition(key, value);
+        }
+        return this.handleObjectValue(key, value);
+    }
+    handleScalarValue(key, value) {
+        if (key === '$eq') {
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, '=');
+        }
+        return this.buildSimpleCondition(key, value, '=');
+    }
+    handleObjectValue(key, value) {
+        if (this.isLogicalOperator(key)) {
+            return this.buildLogicalOperatorCondition(key, value);
+        }
+        if (this.isNorOperator(key)) {
+            return this.buildNorCondition(value);
+        }
+        return this.buildOperatorConditions(key, value);
+    }
+    buildLogicalOperatorCondition(key, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const operator = this.extractLogicalOperator(key);
+        return this.wrapWithLogicalOperator(conditions, operator);
+    }
+    buildOperatorConditions(key, value) {
+        const parts = [];
+        for (const operator of this.OPERATORS) {
+            if (operator in value) {
+                const condition = this.buildOperatorCondition(key, operator, value[operator]);
+                parts.push(condition);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    buildOperatorCondition(key, operator, value) {
+        switch (operator) {
+            case '$eq':
+                return this.buildSimpleCondition(key, value, '=');
+            case '$ne':
+                return this.buildSimpleCondition(key, value, '!=');
+            case '$in':
+                return this.buildInCondition(key, value);
+            case '$nin':
+                return this.buildNotInCondition(key, value);
+            case '$like':
+                return this.buildLikeCondition(key, value);
+            case '$gt':
+                return this.buildComparisonCondition(key, value, '>');
+            case '$gte':
+                return this.buildComparisonCondition(key, value, '>=');
+            case '$lt':
+                return this.buildComparisonCondition(key, value, '<');
+            case '$lte':
+                return this.buildComparisonCondition(key, value, '<=');
+            case '$and':
+            case '$or':
+                return this.buildNestedLogicalCondition(operator, value);
+            case '$nor':
+                return this.buildNorCondition(value);
+            default:
+                return '';
+        }
+    }
+    buildSimpleCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} IN (${formattedValues})`;
+    }
+    buildNotInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} NOT IN (${formattedValues})`;
+    }
+    buildLikeCondition(key, value) {
+        const column = this.resolveColumnName(key);
+        return `${column} LIKE '${value}'`;
+    }
+    buildComparisonCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildNestedLogicalCondition(operator, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const logicalOp = this.extractLogicalOperator(operator);
+        return this.wrapWithLogicalOperator(conditions, logicalOp);
+    }
+    buildNorCondition(value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const wrapped = this.wrapWithLogicalOperator(conditions, 'OR');
+        return `NOT ${wrapped}`;
+    }
+    wrapWithLogicalOperator(conditions, operator) {
+        return `(${conditions.join(` ${operator} `)})`;
+    }
+    extractValueFromValueObject(value) {
+        if ((0, utils_1.extendsFrom)(value_object_1.ValueObject, value?.constructor?.prototype)) {
+            return value.getValue();
+        }
+        return value;
+    }
+    formatValue(value) {
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (this.isNullish(value))
+            return 'NULL';
+        if (this.isPrimitive(value))
+            return this.formatPrimitive(value);
+        return this.formatJson(value);
+    }
+    formatDate(value) {
+        return `'${value.toISOString()}'`;
+    }
+    isNullish(value) {
+        return value === null || value === undefined;
+    }
+    isPrimitive(value) {
+        return ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+    }
+    formatPrimitive(value) {
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        return `${value}`;
+    }
+    formatJson(value) {
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    escapeString(value) {
+        return value.replace(/'/g, "''");
+    }
+    isScalarValue(value) {
+        const isDate = value instanceof Date;
+        return typeof value !== 'object' || value === null || isDate;
+    }
+    isArrayValue(key, value) {
+        return !this.OPERATORS.includes(key) && Array.isArray(value);
+    }
+    isLogicalOperator(key) {
+        return ['$or', '$and'].includes(key);
+    }
+    isNorOperator(key) {
+        return key === '$nor';
+    }
+    extractLogicalOperator(key) {
+        return key.toUpperCase().replace('$', '');
+    }
+    trackLastNonOperatorKey(key) {
+        if (!this.OPERATORS.includes(key)) {
+            this.lastKeyNotOperator = key;
+        }
+    }
+    resolveColumnName(property) {
+        if (property.startsWith('$')) {
+            return property;
+        }
+        const column = this.columnMap[property];
+        if (column) {
+            return column;
+        }
+        return (0, utils_1.toSnakeCase)(property);
+    }
+    buildNullCondition(column, operator) {
+        if (operator === '!=' || operator === '<>')
+            return `${column} IS NOT NULL`;
+        return `${column} IS NULL`;
+    }
+}
+exports.IndexConditionBuilder = IndexConditionBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.143",
+  "version": "0.1.144",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "698043086053a80b0e1fe53adb89ac494ef92f9f"
+  "gitHead": "73bccb890079ef872f5dcb9f9df1a1a9dfad5912"
 }