fix: use a prefix on SelectQueryBuilder internal parameters (#5178)

* Use a leading underscore on SelectQueryBuilder internal parameters

* Add test case for issue #5174

* Fix lint issues

* Improve test for issue #5174

* Use a different prefix for the former ...ids

* Remove .only

src/query-builder/SelectQueryBuilder.ts

@@ -1853,8 +1853,9 @@ export class SelectQueryBuilder<Entity> extends QueryBuilder<Entity> implements
                 if (metadata.hasMultiplePrimaryKeys) {
                     condition = rawResults.map((result, index) => {
                         return metadata.primaryColumns.map(primaryColumn => {
-                            parameters[`ids_${index}_${primaryColumn.databaseName}`] = result[`ids_${mainAliasName}_${primaryColumn.databaseName}`];
-                            return `${mainAliasName}.${primaryColumn.propertyPath}=:ids_${index}_${primaryColumn.databaseName}`;
+                            const paramKey = `orm_distinct_ids_${index}_${primaryColumn.databaseName}`;
+                            parameters[paramKey] = result[`ids_${mainAliasName}_${primaryColumn.databaseName}`];
+                            return `${mainAliasName}.${primaryColumn.propertyPath}=:${paramKey}`;
                         }).join(" AND ");
                     }).join(" OR ");
                 } else {
@@ -1864,8 +1865,8 @@ export class SelectQueryBuilder<Entity> extends QueryBuilder<Entity> implements
                         // fixes #190. if all numbers then its safe to perform query without parameter
                         condition = `${mainAliasName}.${metadata.primaryColumns[0].propertyPath} IN (${ids.join(", ")})`;
                     } else {
-                        parameters["ids"] = ids;
-                        condition = mainAliasName + "." + metadata.primaryColumns[0].propertyPath + " IN (:...ids)";
+                        parameters["orm_distinct_ids"] = ids;
+                        condition = mainAliasName + "." + metadata.primaryColumns[0].propertyPath + " IN (:...orm_distinct_ids)";
                     }
                 }
                 rawResults = await this.clone()

test/github-issues/5174/entity/Role.ts

@@ -0,0 +1,14 @@
+import {Entity} from "../../../../src/decorator/entity/Entity";
+import {PrimaryColumn, OneToMany} from "../../../../src";
+import {User} from "./User";
+
+@Entity()
+export class Role {
+
+  @PrimaryColumn()
+  id: string;
+
+  @OneToMany(_ => User, user => user.role, { cascade: true })
+  users: User[];
+
+}

test/github-issues/5174/entity/User.ts

@@ -0,0 +1,14 @@
+import {Entity} from "../../../../src/decorator/entity/Entity";
+import {PrimaryColumn, ManyToOne} from "../../../../src";
+import {Role} from "./Role";
+
+@Entity()
+export class User {
+
+  @PrimaryColumn()
+  id: number;
+
+  @ManyToOne(_ => Role, role => role.users)
+  role: Role;
+
+}

test/github-issues/5174/issue-5174.ts

@@ -0,0 +1,52 @@
+import "reflect-metadata";
+import {expect} from "chai";
+import {Connection} from "../../../src";
+import {User} from "./entity/User";
+import {Role} from "./entity/Role";
+import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../utils/test-utils";
+
+describe("github issues > #5174 `selectQueryBuilder.take` messes up the query when using the `ids` parameter", () => {
+
+    let connections: Connection[];
+
+    before(async () => {
+        connections = await createTestingConnections({
+            entities: [User, Role],
+            schemaCreate: true,
+            dropSchema: true
+        });
+    });
+    beforeEach(() => reloadTestingDatabases(connections));
+    after(() => closeTestingConnections(connections));
+
+    it("should allow the 'ids' parameter without messing up the query when using .take", () =>
+    Promise.all(connections.map(async (connection) => {
+        const roleRepository = connection.getRepository(Role);
+        const userRepository = connection.getRepository(User);
+
+        const userWithId = (id: number) => ({ id });
+
+        await roleRepository.save([
+            { id: "a", users: [1, 2, 3].map(userWithId) },
+            { id: "b", users: [9, 10, 11, 12, 13].map(userWithId) },
+            { id: "c", users: [14, 15, 16, 17].map(userWithId) }
+        ]);
+
+
+        const results = await userRepository.createQueryBuilder("user")
+            .leftJoinAndSelect("user.role", "role")
+            .where("role.id IN (:...ids)", { ids: ["a", "c"] })
+            .take(5)
+            .orderBy("user.id")
+            .getMany();
+
+        expect(results).to.be.deep.equal([
+            { id: 1, role: { id: "a" } },
+            { id: 2, role: { id: "a" } },
+            { id: 3, role: { id: "a" } },
+            { id: 14, role: { id: "c" } },
+            { id: 15, role: { id: "c" } }
+        ]);
+    })));
+
+});