@cheetah.js/orm 0.1.96 → 0.1.98

package/dist/SqlBuilder.d.ts

@@ -55,6 +55,12 @@ export declare class SqlBuilder<T> {
     private objectToStringMap;
     private mapObjectKey;
     private isNestedObject;
+    private buildColumnPath;
+    private splitPath;
+    private resolvePathEntity;
+    private nextEntity;
+    private resolveColumn;
+    private joinSegments;
     private getTableName;
     private t;
     private getEntity;

package/dist/SqlBuilder.js

@@ -310,7 +310,8 @@ class SqlBuilder {
             return this.objectToStringMap(obj[key], fullKey);
         }
         if (parentKey) {
-            return [`${this.columnManager.discoverAlias(fullKey, true)} ${obj[key]}`];
+            const columnPath = this.buildColumnPath(fullKey);
+            return [`${this.columnManager.discoverAlias(columnPath, true)} ${obj[key]}`];
         }
         const columnName = value_processor_1.ValueProcessor.getColumnName(key, this.entity);
         return [`${this.columnManager.discoverAlias(columnName, true)} ${obj[key]}`];
@@ -318,6 +319,45 @@ class SqlBuilder {
     isNestedObject(value) {
         return typeof value === 'object' && value !== null;
     }
+    buildColumnPath(path) {
+        const segments = this.splitPath(path);
+        const entity = this.resolvePathEntity(segments.parents);
+        const column = this.resolveColumn(segments.column, entity);
+        return this.joinSegments(segments.parents, column);
+    }
+    splitPath(path) {
+        const parts = path.split('.');
+        const column = parts.pop() ?? path;
+        return { parents: parts, column };
+    }
+    resolvePathEntity(parents) {
+        let current = this.entity;
+        for (const relation of parents) {
+            current = this.nextEntity(current, relation);
+        }
+        return current;
+    }
+    nextEntity(entity, relation) {
+        const relations = entity.relations ?? [];
+        const meta = relations.find(rel => rel.propertyKey === relation);
+        if (!meta) {
+            throw new Error(`Relationship "${relation}" not found for ORDER BY path`);
+        }
+        const next = this.entityStorage.get(meta.entity());
+        if (!next) {
+            throw new Error(`Entity metadata not found for relation "${relation}"`);
+        }
+        return next;
+    }
+    resolveColumn(column, entity) {
+        return value_processor_1.ValueProcessor.getColumnName(column, entity);
+    }
+    joinSegments(parents, column) {
+        if (parents.length === 0) {
+            return column;
+        }
+        return `${parents.join('.')}.${column}`;
+    }
     getTableName() {
         const tableName = this.entity.tableName || this.model.name.toLowerCase();
         const schema = this.entity.schema || 'public';

package/dist/query/sql-column-manager.d.ts

@@ -22,4 +22,7 @@ export declare class SqlColumnManager {
     private buildJoinMaps;
     private findNextAlias;
     private formatColumnWithAlias;
+    private getColumnNameFromProperty;
+    private getColumnNameFromPropertyForEntity;
+    private getEntityFromAlias;
 }

package/dist/query/sql-column-manager.js

@@ -65,10 +65,11 @@ class SqlColumnManager {
         return column.includes('.');
     }
     buildSimpleColumnAlias(column, alias, onlyAlias) {
+        const columnName = this.getColumnNameFromProperty(column);
         if (onlyAlias) {
-            return `${alias}."${column}"`;
+            return `${alias}."${columnName}"`;
         }
-        return `${alias}."${column}" as ${alias}_${column}`;
+        return `${alias}."${columnName}" as ${alias}_${columnName}`;
     }
     buildNestedColumnAlias(column, onlyAlias) {
         this.validateJoinsExist();
@@ -118,11 +119,39 @@ class SqlColumnManager {
         }
         return null;
     }
-    formatColumnWithAlias(alias, columnName, onlyAlias) {
+    formatColumnWithAlias(alias, propertyName, onlyAlias) {
+        const entity = this.getEntityFromAlias(alias);
+        const columnName = this.getColumnNameFromPropertyForEntity(propertyName, entity);
         if (onlyAlias) {
             return `${alias}."${columnName}"`;
         }
         return `${alias}."${columnName}" as ${alias}_${columnName}`;
     }
+    getColumnNameFromProperty(propertyName) {
+        return this.getColumnNameFromPropertyForEntity(propertyName, this.entity);
+    }
+    getColumnNameFromPropertyForEntity(propertyName, entity) {
+        if (entity.properties[propertyName]) {
+            return entity.properties[propertyName].options.columnName;
+        }
+        const relation = entity.relations?.find(rel => rel.propertyKey === propertyName);
+        if (relation) {
+            return relation.columnName;
+        }
+        return propertyName;
+    }
+    getEntityFromAlias(alias) {
+        if (alias === this.statements.alias) {
+            return this.entity;
+        }
+        const join = this.statements.join?.find(j => j.joinAlias === alias);
+        if (join?.joinEntity) {
+            const entity = this.entityStorage.get(join.joinEntity);
+            if (entity) {
+                return entity;
+            }
+        }
+        return this.entity;
+    }
 }
 exports.SqlColumnManager = SqlColumnManager;

package/package.json

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