@cheetah.js/orm 0.1.92 → 0.1.95

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

@@ -32,5 +32,7 @@ export declare class SqlConditionBuilder<T> {
     private isLogicalOperator;
     private extractLogicalOperator;
     private trackLastNonOperatorKey;
+    private resolveColumnName;
+    private resolveRelationColumn;
 }
 export {};

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

@@ -30,16 +30,16 @@ class SqlConditionBuilder {
         return sqlParts;
     }
     processEntry(key, value, alias, model) {
-        this.trackLastNonOperatorKey(key);
+        this.trackLastNonOperatorKey(key, model);
         const relationship = this.findRelationship(key, model);
         if (relationship) {
             return this.handleRelationship(relationship, value, alias);
         }
         if (this.isScalarValue(value)) {
-            return this.handleScalarValue(key, value, alias);
+            return this.handleScalarValue(key, value, alias, model);
         }
         if (this.isArrayValue(key, value)) {
-            return this.buildInCondition(key, value, alias);
+            return this.buildInCondition(key, value, alias, model);
         }
         return this.handleObjectValue(key, value, alias, model);
     }
@@ -50,11 +50,11 @@ class SqlConditionBuilder {
         }
         return '';
     }
-    handleScalarValue(key, value, alias) {
+    handleScalarValue(key, value, alias, model) {
         if (key === '$eq') {
-            return this.buildSimpleCondition(this.lastKeyNotOperator, value, alias, '=');
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, alias, '=', model);
         }
-        return this.buildSimpleCondition(key, value, alias);
+        return this.buildSimpleCondition(key, value, alias, '=', model);
     }
     handleObjectValue(key, value, alias, model) {
         if (this.isLogicalOperator(key)) {
@@ -80,23 +80,23 @@ class SqlConditionBuilder {
     buildOperatorCondition(key, operator, value, alias, model) {
         switch (operator) {
             case '$eq':
-                return this.buildSimpleCondition(key, value, alias, '=');
+                return this.buildSimpleCondition(key, value, alias, '=', model);
             case '$ne':
-                return this.buildSimpleCondition(key, value, alias, '!=');
+                return this.buildSimpleCondition(key, value, alias, '!=', model);
             case '$in':
-                return this.buildInCondition(key, value, alias);
+                return this.buildInCondition(key, value, alias, model);
             case '$nin':
-                return this.buildNotInCondition(key, value, alias);
+                return this.buildNotInCondition(key, value, alias, model);
             case '$like':
-                return this.buildLikeCondition(key, value, alias);
+                return this.buildLikeCondition(key, value, alias, model);
             case '$gt':
-                return this.buildComparisonCondition(key, value, alias, '>');
+                return this.buildComparisonCondition(key, value, alias, '>', model);
             case '$gte':
-                return this.buildComparisonCondition(key, value, alias, '>=');
+                return this.buildComparisonCondition(key, value, alias, '>=', model);
             case '$lt':
-                return this.buildComparisonCondition(key, value, alias, '<');
+                return this.buildComparisonCondition(key, value, alias, '<', model);
             case '$lte':
-                return this.buildComparisonCondition(key, value, alias, '<=');
+                return this.buildComparisonCondition(key, value, alias, '<=', model);
             case '$and':
             case '$or':
                 return this.buildNestedLogicalCondition(operator, value, alias, model);
@@ -104,23 +104,28 @@ class SqlConditionBuilder {
                 return '';
         }
     }
-    buildSimpleCondition(key, value, alias, operator = '=') {
+    buildSimpleCondition(key, value, alias, operator, model) {
+        const column = this.resolveColumnName(key, model);
         const formattedValue = this.formatValue(value);
-        return `${alias}.${key} ${operator} ${formattedValue}`;
+        return `${alias}.${column} ${operator} ${formattedValue}`;
     }
-    buildInCondition(key, values, alias) {
+    buildInCondition(key, values, alias, model) {
+        const column = this.resolveColumnName(key, model);
         const formattedValues = values.map(val => this.formatValue(val)).join(', ');
-        return `${alias}.${key} IN (${formattedValues})`;
+        return `${alias}.${column} IN (${formattedValues})`;
     }
-    buildNotInCondition(key, values, alias) {
+    buildNotInCondition(key, values, alias, model) {
+        const column = this.resolveColumnName(key, model);
         const formattedValues = values.map(val => this.formatValue(val)).join(', ');
-        return `${alias}.${key} NOT IN (${formattedValues})`;
+        return `${alias}.${column} NOT IN (${formattedValues})`;
     }
-    buildLikeCondition(key, value, alias) {
-        return `${alias}.${key} LIKE '${value}'`;
+    buildLikeCondition(key, value, alias, model) {
+        const column = this.resolveColumnName(key, model);
+        return `${alias}.${column} LIKE '${value}'`;
     }
-    buildComparisonCondition(key, value, alias, operator) {
-        return `${alias}.${key} ${operator} ${value}`;
+    buildComparisonCondition(key, value, alias, operator, model) {
+        const column = this.resolveColumnName(key, model);
+        return `${alias}.${column} ${operator} ${value}`;
     }
     buildNestedLogicalCondition(operator, value, alias, model) {
         const conditions = value.map((cond) => this.build(cond, alias, model));
@@ -155,10 +160,29 @@ class SqlConditionBuilder {
     extractLogicalOperator(key) {
         return key.toUpperCase().replace('$', '');
     }
-    trackLastNonOperatorKey(key) {
+    trackLastNonOperatorKey(key, model) {
         if (!this.OPERATORS.includes(key)) {
             this.lastKeyNotOperator = key;
         }
     }
+    resolveColumnName(property, model) {
+        if (property.startsWith('$')) {
+            return property;
+        }
+        const entity = this.entityStorage.get(model);
+        if (!entity) {
+            return property;
+        }
+        const column = entity.properties?.[property]?.options.columnName;
+        if (column) {
+            return column;
+        }
+        return this.resolveRelationColumn(property, entity) ?? property;
+    }
+    resolveRelationColumn(property, entity) {
+        const relation = entity.relations?.find(rel => rel.propertyKey === property);
+        const column = relation?.columnName;
+        return typeof column === 'string' ? column : undefined;
+    }
 }
 exports.SqlConditionBuilder = SqlConditionBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.92",
+  "version": "0.1.95",
   "description": "A simple ORM for Cheetah.js",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "e9e7573a10d2bc19b03f4265771876ceb6580e6b"
+  "gitHead": "d9b887ebe3cf2b0bb4a2fa1b9e02ef5085342c2f"
 }