Как сохранить пользовательскую таблицу ManyToMany TypeORM

Question

Я пытаюсь сохранить сущность с помощью настраиваемого поля ManyToMany в TypeORM

Основная сущность

@Entity()
export class Routine extends BaseEntity {
  @PrimaryGeneratedColumn()
  id: number;

  @Column('varchar', { length: 50 })
  name: string;

  @Column('timestamptz')
  creationDate: Date;

  @Column('boolean')
  active: boolean;

  @ManyToOne(
    type => User,
    user => user.routines,
    { eager: false },
  )
  user: User;

  @Column()
  userId: number;

  @OneToMany(
    type => ExerciseToRoutine,
    exerciseToRoutine => exerciseToRoutine.routineId,
  )
  public exerciseToRoutine: ExerciseToRoutine[];
} 

JoinTable

@Entity()
export class ExerciseToRoutine extends BaseEntity {
  @PrimaryColumn()
  exerciseId: number;

  @PrimaryColumn()
  routineId: number;

  @Column()
  day: number;

  @ManyToOne(
    type => Routine,
    routine => routine.exerciseToRoutine,
  )
  routine: Routine;

  @ManyToOne(
    type => Exercise,
    exercise => exercise.exerciseToRoutine,
  )
  exercise: Exercise;
}

Код пытается сохранить сущность

const routine = new Routine(name, currentDate, user, exerciseToRoutine, false);
    await this.trySaveRoutine(routine);

Проблема заключается в том, что мне нужно сохранить сущность Routine с ее exercToRoutine (JoinTable to Exercise Entity) до того, как будет автоматически сгенерирован идентификатор Routine, а свойству exercToRoutine нужен этот ID. Так как я должен это сделать ?? Спасибо

Answer 1

Хороший пример ManyToMany и ленивых отношений. Этого будет достаточно, чтобы создать user-author-like.entity.ts и реализовать его там, где это необходимо.

Поскольку он использует обещание ленивых отношений, он не дает мне гибкой возможности использовать его, как я буду sh. Я создал такое решение в своем приложении. Я использую его во всех своих API GraphQL.

user.entity.ts

import { Entity, 
        PrimaryGeneratedColumn, 
        Column, 
        BaseEntity, 
        OneToMany, 
        CreateDateColumn, 
        UpdateDateColumn, 
        ManyToMany, 
        JoinTable, 
        OneToOne } from 'typeorm';
import { ObjectType, 
        ID, 
        Field,  
        InputType, 
        ArgsType, 
        Int } from 'type-graphql';
import { Post } from '../post/post.entity';
import { Author } from '../author/author.entity';

@Entity()
@ObjectType()
export class User extends BaseEntity {

    @PrimaryGeneratedColumn('uuid')
    @Field(() => ID)
    id: string;

    @Column({ name: 'userName', unique: true })
    @Field()
    userName: string;

    @Column({ name: 'email', unique: true })
    @Field()
    email: string;

    @Column()
    password: string;

    @CreateDateColumn({ type: 'timestamp' })
    createdAt: Date;

    @UpdateDateColumn({ type: 'timestamp' })
    updatedAt: Date;

    // user_author_like
    @ManyToMany(() => Author, author => author.yazariBegenenler, { lazy: true })
    @JoinTable({
        name: 'user_author_like',
        joinColumn: {
            name: 'userId',
            referencedColumnName: 'id'
        },
        inverseJoinColumn: {
            name: 'authorId',
            referencedColumnName: 'id'
        }
    })

    @Field(() => [Author])
    begenilenYazarlar: Promise<Author[]>;
}

author.entity.ts

import { Entity, PrimaryGeneratedColumn, Column, BaseEntity, ManyToMany } from 'typeorm';
import { ObjectType, Field, ID } from 'type-graphql';

import { User } from '../user/user.entity';

@Entity()
@ObjectType()
export class Author extends BaseEntity {

    @PrimaryGeneratedColumn('uuid')
    @Field(() => ID)
    id: string;

    @Column()
    @Field()
    title: string

    // yazari begenenler
    @ManyToMany(() => User, user => user.begenilenYazarlar, { lazy: true })
    @Field(() => [User])
    yazariBegenenler: Promise<User[]>

}

user-author-like.entity.ts

import { BaseEntity, PrimaryColumn, Entity, CreateDateColumn } from 'typeorm';

@Entity()
export class UserAuthorLike extends BaseEntity {

    @PrimaryColumn('uuid')
    userId: string;

    @PrimaryColumn('uuid')
    authorId: string;

    @CreateDateColumn({ type: 'timestamp' })
    likedAt: Date;
}

user-author-like.resolver.ts

import { Resolver, Authorized, Mutation, Arg } from 'type-graphql';
import { UserAuthorLike } from './user-author-like.entity';

@Resolver()
export class UserAuthorLikeResolver {

    @Authorized('ADMIN', 'MODERATOR', 'MEMBER')
    @Mutation(() => Boolean)
    async yazarBegen(
        @Arg('userId') userId: string,
        @Arg('authorId') authorId: string
    ): Promise<Boolean> {
        await UserAuthorLike.create({ userId, authorId }).save();
        return true;
    };

    @Authorized('ADMIN', 'MODERATOR', 'MEMBER')
    @Mutation(() => Boolean)
    async yazarBegenme(
        @Arg('userId') userId: string,
        @Arg('authorId') authorId: string
    ): Promise<Boolean> {
        await UserAuthorLike.delete({ userId, authorId });
        return true;
    };

}

Answer 2

Поле OneToMany exerciseToRoutine из Routine не хранит никакого внешнего ключа для ExerciseToRoutine, который будет выполнять саму таблицу соединений. Чтобы сохранить новый объект Routine, просто установите в поле exerciseToRoutine пустой массив. Затем создайте ExerciseToRoutine с только что созданным Routine id.