fix(query-builder): fix pagination when PK uses BigIntType

Closes #4227

packages/core/src/utils/QueryHelper.ts

@@ -237,6 +237,10 @@ export class QueryHelper {
       return (cond as ObjectQuery<T>[]).map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery)) as unknown as ObjectQuery<T>;
     }
 
+    if (platform.isRaw(cond)) {
+      return cond;
+    }
+
     return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
   }
 

packages/knex/src/query/QueryBuilder.ts

@@ -495,6 +495,7 @@ export class QueryBuilder<T extends object = AnyEntity> {
   getKnexQuery(): Knex.QueryBuilder {
     this.finalize();
     const qb = this.getQueryBase();
+    (qb as Dictionary).__raw = true; // tag it as there is now way to check via `instanceof`
 
     Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type ?? QueryType.SELECT, this._cond, qb), this._cond && !this._onConflict);
     Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
@@ -1117,6 +1118,7 @@ export class QueryBuilder<T extends object = AnyEntity> {
     // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
     // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
     const subSubQuery = this.getKnex().select(pks).from(knexQuery);
+    (subSubQuery as Dictionary).__raw = true; // tag it as there is now way to check via `instanceof`
     this._limit = undefined;
     this._offset = undefined;
     const cond = this._cond;

tests/issues/GH4227.test.ts

@@ -0,0 +1,52 @@
+import { Entity, LoadStrategy, OneToMany, ManyToOne, Collection, PrimaryKey, BigIntType } from '@mikro-orm/core';
+import { MikroORM } from '@mikro-orm/postgresql';
+
+@Entity()
+class BidEntity {
+
+  @PrimaryKey({ type: BigIntType })
+  id!: string;
+
+  @ManyToOne('ItemEntity', {
+    serializer: value => value.id,
+    serializedName: 'itemId',
+  })
+  item: any;
+
+}
+
+@Entity()
+class ItemEntity {
+
+  @PrimaryKey({ type: BigIntType })
+  id!: string;
+
+  @OneToMany('BidEntity', 'item', {
+    orphanRemoval: true,
+    strategy: LoadStrategy.JOINED,
+    mappedBy: 'item',
+  })
+  bids = new Collection<BidEntity>(this);
+
+}
+
+let orm: MikroORM;
+
+beforeAll(async () => {
+  orm = await MikroORM.init({
+    dbName: ':memory:',
+    entities: [BidEntity, ItemEntity],
+  });
+  await orm.schema.refreshDatabase();
+});
+
+afterAll(() => orm.close(true));
+
+test('select big int', async () => {
+  await orm.em
+    .createQueryBuilder(ItemEntity, 'item')
+    .select('*')
+    .leftJoinAndSelect('item.bids', 'bids')
+    .limit(10)
+    .getResultAndCount();
+});