@cheetah.js/orm 0.1.85 → 0.1.87

package/dist/SqlBuilder.d.ts

@@ -43,6 +43,12 @@ export declare class SqlBuilder<T> {
     executeAndReturnFirst(): Promise<T | undefined>;
     executeAndReturnFirstOrFail(): Promise<T>;
     executeAndReturnAll(): Promise<T[]>;
+    private hasOneToManyJoinedJoin;
+    private processOneToManyJoinedResult;
+    private attachOneToManyRelations;
+    private removeDuplicatesByPrimaryKey;
+    private getPrimaryKeyName;
+    private getPrimaryKeyNameForEntity;
     executeCount(): Promise<number>;
     private logExecution;
     inTransaction<T>(callback: (builder: SqlBuilder<T>) => Promise<T>): Promise<T>;

package/dist/SqlBuilder.js

@@ -165,11 +165,17 @@ class SqlBuilder {
         }
     }
     async executeAndReturnFirst() {
-        this.statements.limit = 1;
+        const hasOneToManyJoinedJoin = this.hasOneToManyJoinedJoin();
+        if (!hasOneToManyJoinedJoin) {
+            this.statements.limit = 1;
+        }
         const result = await this.execute();
         if (result.query.rows.length === 0) {
             return undefined;
         }
+        if (hasOneToManyJoinedJoin) {
+            return this.processOneToManyJoinedResult(result.query.rows);
+        }
         const entities = result.query.rows[0];
         const model = await this.modelTransformer.transform(this.model, this.statements, entities);
         this.afterHooks(model);
@@ -177,11 +183,21 @@ class SqlBuilder {
         return model;
     }
     async executeAndReturnFirstOrFail() {
-        this.statements.limit = 1;
+        const hasOneToManyJoinedJoin = this.hasOneToManyJoinedJoin();
+        if (!hasOneToManyJoinedJoin) {
+            this.statements.limit = 1;
+        }
         const result = await this.execute();
         if (result.query.rows.length === 0) {
             throw new Error('Result not found');
         }
+        if (hasOneToManyJoinedJoin) {
+            const model = await this.processOneToManyJoinedResult(result.query.rows);
+            if (!model) {
+                throw new Error('Result not found');
+            }
+            return model;
+        }
         const entities = result.query.rows[0];
         const model = await this.modelTransformer.transform(this.model, this.statements, entities);
         this.afterHooks(model);
@@ -203,6 +219,70 @@ class SqlBuilder {
         }
         return results;
     }
+    hasOneToManyJoinedJoin() {
+        if (!this.statements.join || this.statements.join.length === 0) {
+            return false;
+        }
+        if (this.statements.strategy !== 'joined') {
+            return false;
+        }
+        return this.statements.join.some(join => {
+            const relationship = this.entity.relations.find(rel => rel.propertyKey === join.joinProperty);
+            return relationship?.relation === 'one-to-many';
+        });
+    }
+    async processOneToManyJoinedResult(rows) {
+        const primaryKey = this.getPrimaryKeyName();
+        const alias = this.statements.alias;
+        const primaryKeyColumn = `${alias}_${primaryKey}`;
+        const firstRowPrimaryKeyValue = rows[0][primaryKeyColumn];
+        const relatedRows = rows.filter(row => row[primaryKeyColumn] === firstRowPrimaryKeyValue);
+        const model = this.modelTransformer.transform(this.model, this.statements, relatedRows[0]);
+        this.afterHooks(model);
+        this.attachOneToManyRelations(model, relatedRows);
+        return model;
+    }
+    attachOneToManyRelations(model, rows) {
+        if (!this.statements.join) {
+            return;
+        }
+        for (const join of this.statements.join) {
+            const relationship = this.entity.relations.find(rel => rel.propertyKey === join.joinProperty);
+            if (relationship?.relation === 'one-to-many') {
+                const joinedModels = rows.map(row => this.modelTransformer.transform(join.joinEntity, { alias: join.joinAlias }, row));
+                const uniqueModels = this.removeDuplicatesByPrimaryKey(joinedModels, join.joinEntity);
+                model[join.joinProperty] = uniqueModels;
+            }
+        }
+    }
+    removeDuplicatesByPrimaryKey(models, entityClass) {
+        const entity = this.entityStorage.get(entityClass);
+        if (!entity) {
+            return models;
+        }
+        const primaryKey = this.getPrimaryKeyNameForEntity(entity);
+        const seen = new Set();
+        const unique = [];
+        for (const model of models) {
+            const id = model[primaryKey];
+            if (id && !seen.has(id)) {
+                seen.add(id);
+                unique.push(model);
+            }
+        }
+        return unique;
+    }
+    getPrimaryKeyName() {
+        return this.getPrimaryKeyNameForEntity(this.entity);
+    }
+    getPrimaryKeyNameForEntity(entity) {
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
     async executeCount() {
         const result = await this.execute();
         if (result.query.rows.length === 0) {

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

@@ -19,27 +19,28 @@ class SqlJoinManager {
         const relationshipNames = relationshipPath.split('.');
         let currentEntity = this.entity;
         let currentAlias = this.statements.alias;
-        let statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
-        let nameAliasProperty = this.statements.strategy === 'joined' ? 'joinAlias' : 'alias';
-        relationshipNames.forEach((relationshipName, index) => {
-            const relationship = currentEntity.relations.find(rel => rel.propertyKey === relationshipName);
+        for (const relationshipName of relationshipNames) {
+            const relationship = currentEntity.relations.find((rel) => rel.propertyKey === relationshipName);
             if (!relationship) {
-                throw new Error(`Relationship "${relationshipName}" not found in entity`);
+                throw new Error(`Relationship "${relationshipName}" not found in entity "${currentEntity.tableName}"`);
             }
-            const isLastRelationship = index === relationshipNames.length - 1;
-            if (index === (relationshipNames.length - 2 >= 0 ? relationshipNames.length - 2 : 0)) {
-                const join = statement?.find(j => j.joinProperty === relationshipName);
-                if (join) {
-                    currentAlias = join[nameAliasProperty];
-                }
-            }
-            if (relationship.relation === 'many-to-one' && isLastRelationship) {
-                this.applyJoin(relationship, {}, currentAlias);
-                statement = this.statements.strategy === 'joined' ? this.statements.join : this.statements.selectJoin;
-                currentAlias = statement[statement.length - 1][nameAliasProperty];
+            const statement = this.statements.strategy === 'joined'
+                ? this.statements.join
+                : this.statements.selectJoin;
+            const nameAliasProperty = this.statements.strategy === 'joined' ? 'joinAlias' : 'alias';
+            const existingJoin = statement?.find((j) => j.joinProperty === relationshipName && j.originAlias === currentAlias);
+            if (existingJoin) {
+                currentAlias = existingJoin[nameAliasProperty];
+                currentEntity = this.entityStorage.get(relationship.entity());
+                continue;
             }
+            this.applyJoin(relationship, {}, currentAlias);
+            const newStatement = this.statements.strategy === 'joined'
+                ? this.statements.join
+                : this.statements.selectJoin;
+            currentAlias = newStatement[newStatement.length - 1][nameAliasProperty];
             currentEntity = this.entityStorage.get(relationship.entity());
-        });
+        }
     }
     applyJoin(relationShip, value, alias) {
         const { tableName, schema } = this.getTableName();

package/dist/repository/Repository.d.ts

@@ -45,30 +45,30 @@ export declare abstract class Repository<T extends BaseEntity> {
      * });
      * ```
      */
-    find(options: RepositoryFindOptions<T>): Promise<T[]>;
+    find<Hint extends string = never>(options: RepositoryFindOptions<T, Hint>): Promise<T[]>;
     /**
      * Finds a single entity matching the given criteria.
      * Returns undefined if not found.
      */
-    findOne(options: RepositoryFindOneOptions<T>): Promise<T | undefined>;
+    findOne<Hint extends string = never>(options: RepositoryFindOneOptions<T, Hint>): Promise<T | undefined>;
     /**
      * Finds a single entity matching the given criteria.
      * Throws an error if not found.
      */
-    findOneOrFail(options: RepositoryFindOneOptions<T>): Promise<T>;
+    findOneOrFail<Hint extends string = never>(options: RepositoryFindOneOptions<T, Hint>): Promise<T>;
     /**
      * Finds all entities with optional filtering.
      */
-    findAll(options?: Omit<RepositoryFindOptions<T>, 'where'>): Promise<T[]>;
+    findAll<Hint extends string = never>(options?: Omit<RepositoryFindOptions<T>, 'where'>): Promise<T[]>;
     /**
      * Finds an entity by its primary key.
      */
-    findById(id: number | string): Promise<T | undefined>;
+    findById<Hint extends string = never>(id: number | string, options?: Omit<RepositoryFindOneOptions<T, Hint>, 'where'>): Promise<T | undefined>;
     /**
      * Finds an entity by its primary key.
      * Throws an error if not found.
      */
-    findByIdOrFail(id: number | string): Promise<T>;
+    findByIdOrFail<Hint extends string = never>(id: number | string, options?: Omit<RepositoryFindOneOptions<T, Hint>, 'where'>): Promise<T>;
     /**
      * Creates a new entity.
      */
@@ -112,10 +112,10 @@ export declare abstract class Repository<T extends BaseEntity> {
 /**
  * Find options for repository queries.
  */
-export type RepositoryFindOptions<T> = FindOptions<T> & {
+export type RepositoryFindOptions<T, Hint extends string = never> = FindOptions<T, Hint> & {
     where?: FilterQuery<T>;
 };
 /**
  * Find one options for repository queries.
  */
-export type RepositoryFindOneOptions<T> = Omit<RepositoryFindOptions<T>, 'limit' | 'offset'>;
+export type RepositoryFindOneOptions<T, Hint extends string = never> = Omit<RepositoryFindOptions<T, Hint>, 'limit' | 'offset'>;

package/dist/repository/Repository.js

@@ -98,15 +98,15 @@ class Repository {
     /**
      * Finds an entity by its primary key.
      */
-    async findById(id) {
-        return this.findOne({ where: { id } });
+    async findById(id, options) {
+        return this.findOne({ where: { id }, ...options });
     }
     /**
      * Finds an entity by its primary key.
      * Throws an error if not found.
      */
-    async findByIdOrFail(id) {
-        return this.findOneOrFail({ where: { id } });
+    async findByIdOrFail(id, options) {
+        return this.findOneOrFail({ where: { id }, ...options });
     }
     /**
      * Creates a new entity.

package/package.json

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