NestJS + GraphQL: How to avoid circular dependencies in resolvers

Let’s say i have two entities:

// user.entity.ts

@ObjectType()
@Entity()
export class User {
  @Field()
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Field()
  @Column({ unique: true })
  username: string;

  @Column({ select: false })
  password: string;

  @Field(() => [Task])
  @OneToMany(() => Task, (task) => task.author)
  authorOfTasks: Task[]
}

and

// task.entity.ts

@ObjectType()
@Entity()
export class Task {
  @Field()
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Field()
  @Column()
  title: string;

  @Field()
  @Column({ nullable: true })
  description?: string;

  @Field(() => User)
  @ManyToOne(() => User, (user) => user.authorOfTasks)
  author: User;
}

So in resolvers i need to resolve authorOfTasks field in UserResolver and author field in TaskResolver. To do this i need to inject UserService and TaskService in both UserResolver and TaskResolver. Like this:

// user.resolver.ts

@Resolver(of => User)  
export class UserResolver {  
  constructor(  
    private userService: UserService,  
    private taskService: TaskService  
  ) {}  

    // here are some queries that using userService
  
  @ResolveField(() => [Task])  
  async authorOfTasks(  
    @Parent() author: User  
  ) {  
    return this.taskService.getTasksByAuthor(author)  
  }  
}

and

// task.resolver.ts

@Resolver()  
export class TaskResolver {  
  constructor(  
    private taskService: TaskService,  
    private userService: UserService  
  ) {}  
    
  // here are some queries that using taskService  
  
  @ResolveField(() => User)  
  async author(  
    @Parent() task: Task  
  ) {  
    return this.userService.getUserById(task.author.id)  
  }  
}

As you can see there are TaskService and UserService injected in both those resolvers and it ends up with Nest complaining about circular dependencies in my app and suggesting me to use forwardRef to inject those dependencies. Ofcourse i can use that technique, but Nest documentation itself tells me that i should avoid circular dependencies when possible.

So my question is – what to do in this situation? Maybe i should reorganize my app somehow? How then? I want to keep my code modular as much as i can. My current structure looks like this:

Thank you! 🙏