Correct use of ManyToMany relations

[integrITsolutions]

Hi,
I am fairly new to nestjs-query.
Have managed to get the ManyToOne relations to work with the standard resolvers by specifying an ID field on my InputType "categoryId" and then using @joincolumn("categoryId") on the entity. It stores the categoryId in the table and then uses this to resolve the Relation for the ObjectType Output.

Now I am working on a ManyToMany relation with a @jointable, and actually expected nestjs-query to handle (CRUD) this relation automatically, using the JoinTable. But when inserting a new Event Object, the relation with the User Object is not filled. Do I understand this wrong? Or am I missing something?

Here is my basic code example:

//user.entity.ts

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

  @Column()
  @Index({ unique: true, sparse: false })
  email: string;

  @ManyToMany(() => Event)
  events: Event[];
}

//user.dto.ts

@InputType()
export class CreateUserInput {
  @Field()
  email!: string;
  
  @Field(() => [ID])
  eventId!: number[];
}

@FilterableOffsetConnection('events', () => EventOutput)
@ObjectType('User')
export class UserOutput {
  @FilterableField(() => ID)
  id!: number;

  @FilterableField()
  name?: string;

  @FilterableField()
  email!: string;
}

//event.entity.ts

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

  @Column('int', { array: true })
  participantIds: number[];

  @ManyToMany(() => User)
  @JoinTable({ name: 'event_participants' })
  participants: User[];
}

//event.dto.ts

@InputType()
export class EventCreateInput {
  @Field(() => [ID])
  participantIds!: number[];
}

@FilterableUnPagedRelation('participants', () => UserOutput)
@ObjectType('Event')
export class EventOutput {
  @IDField(() => ID)
  id!: number;
}

Do I need to write a custom resolver to handle the ManyToMany relation between Event and User (Participants)?

Grateful for any advice or hints how to make this work 🙏🏼

[TriPSs]

If you are doing many to many without the TypeORM's @ManyToMany that you would indeed need a custom resolver.

[integrITsolutions]

Thanks @TriPSs.
Is there a better way to do this?
How would you use the TypeORM @manytomany correctly in this case?
I am new to nestjs-query and typeorm and couldn't really find a working example for this case

[TriPSs]

If you do not need any custom fields in your many to many you could just follow the docs of typeorm.

[integrITsolutions]

Thanks

[integrITsolutions]

Finally managed to map the relation correctly by using a custom hook 🌈

The issue is that I receive an array of participantIds and first need to fetch the participants based on these ids, for TypeORM to be able to make the proper relation in the JoinTable.

This is done now by defining the ManyToMany relation in the Event entity like this:

@JoinTable({
    name: 'event_participants',
    joinColumn: {
      name: 'event_id',
      referencedColumnName: 'id',
    },
    inverseJoinColumn: {
      name: 'participant_id',
      referencedColumnName: 'id',
    },
  })
  participants: User[];

Defining a custom hook event-participant.hook.ts, which catches the mutation and fetches the corresponding participants (Users) for the given ID'S:

@Injectable()
export class EventParticipantHook
  implements
    BeforeCreateOneHook<EventCreateInput>,
    BeforeUpdateOneHook<EventUpdateInput>
{
  constructor(
    @InjectRepository(User) private userRepository: Repository<User>,
  ) {}

  async run(
    instance: CreateOneInputType<EventCreateInput>,
  ): Promise<CreateOneInputType<EventCreateInput>>;
  async run(
    instance: UpdateOneInputType<EventUpdateInput>,
  ): Promise<UpdateOneInputType<EventUpdateInput>>;
  async run(instance: any): Promise<any> {
    if (this.isCreateOneInputType(instance)) {
      // Handle CreateOneInputType
      if (instance.input.participantIds) {
        const participants = await this.userRepository.findBy({
          id: In(instance.input.participantIds),
        });
        instance.input.participants = participants;
      }
    } else if (this.isUpdateOneInputType(instance)) {
      // Handle UpdateOneInputType
      if (instance.update.participantIds) {
        const participants = await this.userRepository.findBy({
          id: In(instance.update.participantIds),
        });
        instance.update.participants = participants;
      }
    }

    return instance;
  }

  private isCreateOneInputType(
    instance: any,
  ): instance is CreateOneInputType<EventCreateInput> {
    return instance.input !== undefined;
  }

  private isUpdateOneInputType(
    instance: any,
  ): instance is UpdateOneInputType<EventUpdateInput> {
    return instance.update !== undefined;
  }
}

registering the Hook and UserModule in event.module.ts:

@Module({
  imports: [
    EventCategoryModule,
    UserModule,
    NestjsQueryGraphQLModule.forFeature({
      imports: [NestjsQueryTypeOrmModule.forFeature([Event, User])],
      resolvers: [
        {
          DTOClass: EventOutput,
          EntityClass: Event,
          CreateDTOClass: EventCreateInput,
          UpdateDTOClass: EventUpdateInput,
          guards: [JwtAuthGuard],
        },
      ],
    }),
  ],
  providers: [EventParticipantHook],
})
export class EventModule {}

And finally applying the hook to my event.dto.ts to catche the mutation and map the participants:

@InputType()
@BeforeCreateOne(EventParticipantHook)
export class EventCreateInput {
  @Field(() => [ID])
  participantIds!: number[];
}

@InputType()
@BeforeUpdateOne(EventParticipantHook)
export class EventUpdateInput {
  @Field(() => [ID], { nullable: true })
  participantIds?: number[];
}

now I am able to retrieve the correct relation in my ObjectType:

@FilterableUnPagedRelation('participants', () => UserOutput)
@ObjectType('Event')
export class EventOutput {
  @IDField(() => ID)
  id!: number;
 }

Works like a charm! 🚀
Thanks for pointing in the right direction @TriPSs