在带有GraphQL的TypeORM多对多关系上使用数据加载器，查询多对多

// Student.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from 'typeorm';
import { Course } from './Course';

@Entity()
export class Student {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @ManyToMany(() => Course, (course) => course.students)
  @JoinTable()
  courses: Course[];
}

// Course.ts
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from 'typeorm';
import { Student } from './Student';

@Entity()
export class Course {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @ManyToMany(() => Student, (student) => student.courses)
  students: Student[];
}

// dataloaders.ts
import DataLoader from 'dataloader';
import { getRepository } from 'typeorm';
import { Student } from './Student';
import { Course } from './Course';

export const studentLoader = new DataLoader(async (courseIds) => {
  const students = await getRepository(Student)
    .createQueryBuilder('student')
    .leftJoinAndSelect('student.courses', 'course', 'course.id IN (:...courseIds)', { courseIds })
    .getMany();
  return courseIds.map(courseId => students.filter(student => student.courses.some(course => course.id === courseId)));
});

export const courseLoader = new DataLoader(async (studentIds) => {
  const courses = await getRepository(Course)
    .createQueryBuilder('course')
    .leftJoinAndSelect('course.students', 'student', 'student.id IN (:...studentIds)', { studentIds })
    .getMany();
  return studentIds.map(studentId => courses.filter(course => course.students.some(student => student.id === studentId)));
});

// resolvers.ts
import { Resolver, Query, Arg } from 'type-graphql';
import { Student } from './Student';
import { Course } from './Course';
import { studentLoader, courseLoader } from './dataloaders';

@Resolver(Student)
export class StudentResolver {
  @Query(() => [Student])
  async students() {
    return getRepository(Student).find();
  }

  @Query(() => Course, { nullable: true })
  async course(@Arg('studentId') studentId: number) {
    const student = await getRepository(Student).findOne(studentId);
    return studentLoader.load(studentId);
  }
}

@Resolver(Course)
export class CourseResolver {
  @Query(() => [Course])
  async courses() {
    return getRepository(Course).find();
  }

  @Query(() => Student, { nullable: true })
  async student(@Arg('courseId') courseId: number) {
    const course = await getRepository(Course).findOne(courseId);
    return courseLoader.load(courseId);
  }
}

// 使用数据加载器
const student = await studentLoader.load(studentId);

// 手动清除缓存
studentLoader.clear(studentId).then(() => {
  const student = await studentLoader.load(studentId);
});