TypeORM - EntityColumnNotFound：未找到实体列“anträge”

Question

I am trying to update an entity in my Angular frontend, in my case an user (Benutzer), but I get the error EntityColumnNotFound: No entity column "anträge" was found. in NestJS (TypeORM). The error comes, when I use the updateBenutzer Service/Controller. My code looks as follows:

benutzer.entity.ts

@Entity()
export class Benutzer {
    @PrimaryGeneratedColumn({ type: "int" })
    BenutzerID: number;

    @Column({ type: "varchar", length: 50})
    Benutzername: string;

    @Column({ type: "varchar", length: 50})
    Passwort: string;

    @Column({ default: false})
    istAdmin: boolean;

    @Column({ default: false})
    istVorgesetzter: boolean;

    @Column({ type: "int"})
    Vorgesetzter: number;

    @Column({ type: "varchar", length: 50})
    Vorname: string;

    @Column({ type: "varchar", length: 50})
    Nachname: string;

    @Column()
    Geburtsdatum: Date;

    @Column({ type: "varchar", length: 50})
    Email: string;

    @Column()
    Eintrittsdatum: Date;

    @ManyToOne(() => Arbeitstage, arbeitstage => arbeitstage.allebenutzer)
    arbeitstage: Arbeitstage;

    @ManyToOne(() => Bundesland, bundesland => bundesland.alleBenutzer)
    bundesland: Bundesland;

    @OneToMany(() => Urlaubsantrag, urlaubsantrag => urlaubsantrag.benutzer)
    anträge: Urlaubsantrag[];
}

urlaubsantrag.entity.ts

@Entity()
export class Urlaubsantrag {
    @PrimaryGeneratedColumn({ type: "int" })
    AntragID: number;

    @Column({ type: "varchar", length: 50 })
    Urlaubsart: string;

    @Column({ type: "varchar", length: 50})
    Status: string;
    @Column()
    von: Date;

    @Column()
    bis: Date;

    @Column({ type: "varchar", length: 50})
    Grund: string;

    @Column()
    informiert: boolean;

    @ManyToOne(() => Benutzer, benutzer => benutzer.anträge, { onDelete: 'CASCADE' })
    benutzer: Benutzer;
}

benutzer.service.ts

@Injectable()
export class BenutzerService {
    constructor(
        @InjectRepository(Benutzer)
        private benutzerRepository: Repository<Benutzer>,
      ) {}
    
      getAllBenutzer(): Promise<Benutzer[]> {
        return this.benutzerRepository.find({ relations: ['bundesland', 'arbeitstage', 'anträge']});
      }
    
      findBenutzerByID(id: number): Promise<Benutzer> {
        return this.benutzerRepository.findOne(id, { relations: ['bundesland', 'arbeitstage', 'anträge']});
      }

      async findBenutzerByVorgesetzter(id: number): Promise<Benutzer[]> {
        return this.benutzerRepository.find({ where: {Vorgesetzter: id}});
      }

      getAllVorgesetzten(istVorgesetzter: boolean): Promise<Benutzer[]>{
        return this.benutzerRepository.find({ where: {istVorgesetzter: istVorgesetzter} });
      }

      async createBenutzer(benutzer: CreateBenutzer) {
        const nutzer = this.benutzerRepository.create(benutzer);
        await this.benutzerRepository.save(benutzer);
        return nutzer;
      }

      async updateBenutzer(id: number, createBenutzerDTO: CreateBenutzer) {
        return await this.benutzerRepository.update( id, createBenutzerDTO);
      }
    
      async deleteBenutzer(id: number): Promise<DeleteResult> {
        return await this.benutzerRepository.findOne(id).then((value) => {
          return this.benutzerRepository.delete(value);
        });
      }
}

benutzer.controller.ts

@Controller('benutzer')
export class BenutzerController {
    constructor(private readonly benutzerService: BenutzerService) {}

    @Post()
    async createBenutzer(@Body() createBenutzer: CreateBenutzer): Promise<Benutzer> {
    return this.benutzerService.createBenutzer(createBenutzer);
    }

    @Get()
    async getBenutzer(): Promise<Benutzer[]> {
        return this.benutzerService.getAllBenutzer();
    }

    @Get('/vorgesetzter')
    async getAllVorgesetzten(@Query('istVorgesetzter', new ParseBoolPipe()) istVorgesetzter: boolean): Promise<Benutzer[]>{
      return this.benutzerService.getAllVorgesetzten(istVorgesetzter);
    }

    @Get(':id')
    async getBenutzerByID(@Param('id', new ParseIntPipe()) id): Promise<Benutzer> {
        return this.benutzerService.findBenutzerByID(id);
    }

    @Get('/vorgesetzter/:id')
    async getBenutzerByVorgesetzter(@Param('id', new ParseIntPipe()) id): Promise<Benutzer[]> {
        return this.benutzerService.findBenutzerByVorgesetzter(id);
    }

    @Put(':id')
    updateBenutzer(@Param('id') id: number, @Body() createBenutzerDTO: CreateBenutzer) {
    return this.benutzerService.updateBenutzer(id, createBenutzerDTO);
    } 

    @Delete(':id')
    async remove(@Param('id', new ParseIntPipe()) id) {
    return this.benutzerService.deleteBenutzer(id);
  }
}

create-benutzer.dto.ts

    export class CreateBenutzer {
    @IsString()
    @MinLength(4)
    @MaxLength(20)
    readonly Benutzername: string;

    @IsString()
    @MinLength(4)
    @MaxLength(20)
    //@Matches(/((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/, 
    //{message: 'das Passwort ist zu schwach'})
    readonly Passwort: string;
    readonly istAdmin: boolean;
    readonly istVorgesetzter: boolean;
    readonly Vorgesetzter: number;
    readonly Vorname: string;
    readonly Nachname: string;
    readonly Geburtsdatum: Date;
    readonly Email: string;
    readonly Eintrittsdatum: Date;
    readonly arbeitstage: Arbeitstage;
    readonly bundesland: Bundesland;
}

Answer 1

To solve your problem you can use the Save method for updating the entity:
the reason is the save method executes a primitive operation without cascades and relations operations.

 async updateBenutzer(id: number, createBenutzerDTO: CreateBenutzer) {

 let benutzerUpdate= await this.benutzerRepository.findOne({ BenutzerID:id});
 if(!benutzerUpdate) throw new NotFoundException({message:"Benutzer doesn't exist" });

    return this.benutzerRepository.save({...benutzerUpdate,...createBenutzerDTO});

  }