TypeORM update with join table (One-To-Many, Many-To-One) - mysql

Question

There are two example entities.
#Entity('companies')
export class Company {
#PrimaryColumn({ name: 'id' })
id: string;
#Column({ name: 'name' })
name: string;
#OneToMany(() => employee, (employee) => employee.company)
#JoinColumn({ name: 'id', referencedColumnName: 'company_id' })
employees: Employee[];
}
#Entity('employees')
export class Employee {
#PrimaryColumn({ name: 'id' })
id: string;
#Column({ name: 'name' })
name: string;
#ManyToOne(() => company, (employee) => company.employees, { eagar: true, cascade: true} )
#JoinColumn({ name: 'company_id', referencedColumnName: 'id' })
company: Company;
}
And I prepared the entity as follows for the update. (It can update my company's information or my employees' information.)
const employee = new Employee();
employee.id = 'employee1';
employee.name = 'mike';
const companyEntity = await companyRepository.findByEmployeeId(employee_id);
companyEntity.name = 'stackoverflow';
companyEntity.employees = [employee];
await companyRepository.save(companyEntity);
If save like this, an error occurs because TypeORM processes as follows. (It wasn't an exact error. It was a similar error.)
// (Before the update, All users with 'company1' company have been inquired.)
query: SELECT employee.id FROM employee WHERE employee.company_id = 'company1'
query: UPDATE employee SET company_id = NULL WHERE employee.id = 'employee2'
query: UPDATE employee SET company_id = NULL WHERE employee.id = 'employee3'
query failed: Column 'company_id' cannot be NULL
In the end, it seems to be an error caused by all users belonging to the company trying to be inquired and updated.
What should I do to update the employees using the save method?

Answer 1

Check your employee.entitiy file, I think you may have the relationship not quite right:
// company.entity.ts
#Entity('companies')
export class Company {
#PrimaryColumn({ name: 'id' })
id: string;
#Column({ name: 'name' })
name: string;
#OneToMany(() => Employee, (employee) => employee.company)
employees: Employee[];
}
// employee.entity.ts
#Entity('employees')
export class Employee {
#PrimaryColumn({ name: 'id' })
id: string;
#Column({ name: 'name' })
name: string;
#ManyToOne(() => Company, (company) => company.employees)
#JoinColumn({
name: 'company_id',
})
company: Company;
}
Personally, when updating a record, I'll do something like this—using your employee as an example:
// employee.service.ts
async updateEmployee(
employeeId: string,
updateEmployeeDto: UpdateEmployeeDto,
): Promise<Employee> {
/**
* This will stop the show and return a 404 if the employee cannot be found.
*/
const employee = await this.getEmployeeById(employeeId);
const { name } = updateEmployeeDto;
employee.name = name;
try {
await employee.save();
} catch (err) {
throw new InternalServerErrorException(err.message);
}
return employee;
}
Or, if I am doing a create it might look something like this:
// employee.service.ts
async createEmployee(createEmployeeDto: CreateEmployeeDto): Promise<Employee> {
return await this.employeeRepository.createEmployee(createEmployeeDto);
}
// employee.repository.ts
async createUser(createEmployeeDto: CreateEmployeeDto): Promise<Employee> {
const { name } = createEmployeeDto;
const employee = this.create();
employee.name = name;
try {
await employee.save();
} catch (err) {
throw new InternalServerErrorException(err.message);
}
return employee;
}