in v5 the sql querybuilder's order by method type definition uses unknown instead of T

[rhyek]

in v5 the sql querybuilder's order by method's param is typed as orderBy(orderBy: QueryOrderMap<unknown> | QueryOrderMap<unknown>[]): this;

Should it not be orderBy(orderBy: QueryOrderMap<T> | QueryOrderMap<T>[]): this;?

[B4nan]

QB is not really type safe, as you often want to use aliased property names and that can't be type checked (nowadays maybe with string literal types, but seems like a bit unreal task to accomplish tbh). qb.where is the same story, you can pass anything in there.

If we do that, it would force usage of expr helper for all aliased keys. A breaking change that I don't really want to do, given 5.0 was just released.

[rhyek]

where is typed as where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this; and works as expected.
this snipped produces the the sql i expect:

@Entity()
export class TaskEntity {
  @PrimaryKey()
  id!: number;

  ...
}

const qb = this.tasksRepository // EntityRepository<TaskEntity>
  .createQueryBuilder()
  .where({
    id: 3 // typed correctly
  })
  .orderBy({
    id: 'ASC' // typed correctly
  } as QueryOrderMap<TaskEntity>);

that produces the following sql:

select 
  `t0`.* 
from 
  `task` as `t0` 
where 
  `t0`.`id` = 3 
order by 
  `t0`.`id` asc

The as QueryOrderMap<TaskEntity> feels out of place when compared to the where clause.

[B4nan]

QBFilterQuery is basically any dictionary (check the type definition), its like that to allow autocomplete, but you can still pass anything. we can do that for order by too.

we are talking about types, so what SQL is produced is not really important

my point is that you can as well want to write it like this:

const qb = this.tasksRepository // EntityRepository<TaskEntity>
  .createQueryBuilder('t')
  .where({
    't.id': 3
  })
  .orderBy({
    't.id': 'ASC'
  });

[rhyek]

But it autocompletes correctly:

I'm certain autocomplete has worked since v4 as well.

[B4nan]

yes, as i said, it is like that exactly to allow autocomplete, it intersectsjoins FilterQuery with Dictionary type to allow passing anything while preserving autocomplete

export type QBFilterQuery<T = any> = FilterQuery<T> | Dictionary;

[rhyek]

Oh, I see. Yes, that makes sense. Well I think the same behaviour for order by would be useful.
If I change the definition to orderBy(orderBy: QueryOrderMap<T> | QueryOrderMap<T>[]): this; it does what I need it to, but you're right that it doesn't allow for unknown properties.

[B4nan]

fdf03c3