Node.JS Typescript TypeORM findOneBy({id: id}) 错误

Question

I am using "typeorm": "^0.3.7" .

    public override async GetById (id: number): Promise<Student | null> {
        return await this._repository.findOneByOrFail({ id: id });
    }

fails:

error TS2345: Argument of type '{ id: number; }' is not assignable to parameter of type 'FindOptionsWhere<Student> | FindOptionsWhere<Student>[]'.

EntityBase.ts :

import { Entity, PrimaryGeneratedColumn, Column, BaseEntity } from "typeorm"
@Entity()
export abstract class EntityBase extends BaseEntity {
    @PrimaryGeneratedColumn()
    public id: number
    @Column()
    public created: Date
    @Column()
    public modified: Date
    constructor() {
        super();
        this.created = new Date();
    }
}

Student.ts entity:

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm"
import { EntityBase } from "./EntityBase"
@Entity()
export class Student extends EntityBase {
    @Column()
    public firstName: string

    @Column()
    public lastName: string

    @Column({ unique: true })
    public email: string

    @Column()
    public isSuspended: Boolean
    constructor(first: string, last: string, email: string, isSuspended?: boolean) {
        super();
        this.firstName = first;
        this.lastName = last;
        this.email = email;
        this.isSuspended = isSuspended ?? false;
    }
}

RepositoryBase.ts :

import { IRepository, EntityBase } from "core"
import { Database } from "../../db"
import { EntityTarget, Repository } from "typeorm"
export abstract class RepositoryBase<T extends EntityBase> implements IRepository<T> {
    protected _repository: Repository<T>;
    constructor(entity: EntityTarget<T>) {
        this._repository = Database.AppDataSource.getRepository(entity);
    }
    public async GetById (id: number): Promise<T | null> {
        return await this._repository.findOneByOrFail({ id: id });
    }
    public async GetByEmail (email: string): Promise<T | null> {
        return await this._repository.findOneByOrFail({ email: email });
    }
    public async ListAll (): Promise<T[]> {
        return await this._repository.find();
    }
    public async Add (entity: T): Promise<T> {
        return await this._repository.save(entity)
    }
    public async Update (entity: T): Promise<T> {
        entity.modified = new Date();
        return await this._repository.save(entity);
    }
    public async Delete (id: number): Promise<Number> {
        let result = await this._repository.delete(id);
        return result.affected ?? 0;
    }
}

StudentRepository.ts :

import { EntityBase, Student } from "core"
import { RepositoryBase } from "./RepositoryBase"
import { FindOptionsWhere } from "typeorm"
export class StudentRepository<Student extends EntityBase> extends RepositoryBase<Student> {
    constructor() {
        super(Student);
    }
}

What do I miss?

Answer 1

In the StudentRepository we don't need to add the generic type variables in <>. Essentially you want to extend the RepositoryBase with Student type so this will work

export class StudentRepository extends RepositoryBase<Student> {
    constructor() {
        super(Student);
    }

    public override async GetById (id: number): Promise<Student | null> {
        return this._repository.findOneByOrFail({ id });
    }
}

Writing StudentRepository<Student extends EntityBase> makes it generic as well - it's the same as writing T (or anything else) rather than Student.

Hope this solves it for you as well!

PS just a side note: await keyword isn't required when returning from an async function unless it's in a try..catch as explained here