Javascript 如何在nestjs中保存多对多关系_Javascript_Node.js_Nestjs

Javascript 如何在nestjs中保存多对多关系

javascript node.js nestjs

Javascript 如何在nestjs中保存多对多关系,javascript,node.js,nestjs,Javascript,Node.js,Nestjs,我有两个实体Post实体和类别实体，具有多个关系。我的问题是如何保存多对多关系。我所做的是创建了一个多对多关系，我们可以在其中添加自定义属性。为此，我创建了CategoryPost实体，它是Post实体和类别实体 PostEntity.ts import { CategoryPost } from "src/categoryAndPost/category-post.entity"; import { User } from "src/user/user.enti

我有两个实体<代码>Post实体和

类别实体

，具有

多个

关系。我的问题是如何保存多对多关系。我所做的是创建了一个多对多关系，我们可以在其中添加自定义属性。为此，我创建了

CategoryPost

实体，它是

Post实体

和

类别实体

PostEntity.ts

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { User } from "src/user/user.entity";
import { BaseEntity, Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity({name: 'post'})
export class PostEntity extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    body: string

    @ManyToOne(() => User, (user: User) => user.posts, {eager: true})
    @JoinColumn({name: 'user_id'})
    user: User

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.post, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { BaseEntity, Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Category extends BaseEntity{

    @PrimaryGeneratedColumn()
    id: number

    @Column()
    label: string

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.category, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import {Body, Controller, Get, Post} from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm';
import { CategoryRepository } from 'src/category/category.repository';
import { UserRepository } from 'src/user/user.repository';
import { CreatePostDto } from './dto/create-post.dto';
import { PostEntity } from './post.entity';
import { PostService } from './post.service';

@Controller('/post')
@UseGuard(AuthGuard())
export class PostController{
    constructor(private postService: PostService, @InjectRepository(UserRepository) private userRepository: UserRepository, @InjectRepository(CategoryRepository) private categoryRepository: CategoryRepository){}
    @Post('/create')
    async createPost(@Body() createPostDto: CreatePostDto, @getUser: user): Promise<PostEntity>{
        const category1 = await this.categoryRepository.findOne({label: createPostDto.category1})
        const category2 = await this.categoryRepository.findOne({label: createPostDto.category2})
        
        return this.postService.createPost(createPostDto, user, category1, category2)
    }

    @Get()
    async getPost(){
        return this.postService.getPost()
    }
}

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";
import { PostRepository } from "./post.repository";

@Injectable()
export class PostService{
    constructor(@InjectRepository(PostRepository) private postRepository: PostRepository){}

    createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        return this.postRepository.createPost(createPostDto, user, category1, category2)
    }

    async getPost(){
        const post = await this.postRepository.findOne("3")
        return post
    }
}

import { EntityRepository, Repository } from "typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";

@EntityRepository(PostEntity)
export class PostRepository extends Repository<PostEntity>{
    async createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        const {body} = createPostDto
        const post = new PostEntity()
        post.body = body
        post.user = user
        
        post.categoriesPosts = [category1, category2]
        await post.save()
        return post
    }
}

CategoryPost.ts

，它是

Category

和

Post

实体的连接点

import { Category } from "src/category/category.entity";
import { PostEntity } from "src/post/post.entity";
import { BaseEntity, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from "typeorm";

@Entity({name: 'category_post'})
export class CategoryPost extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number

    @ManyToOne(() => PostEntity, post => post.categoriesPosts)
    @JoinColumn({name: 'post_id'})
    post: PostEntity

    @ManyToOne(() => Category, category => category.categoriesPosts)
    @JoinColumn({name: 'category_id'})
    category: Category
}

Category.ts

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { User } from "src/user/user.entity";
import { BaseEntity, Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity({name: 'post'})
export class PostEntity extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    body: string

    @ManyToOne(() => User, (user: User) => user.posts, {eager: true})
    @JoinColumn({name: 'user_id'})
    user: User

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.post, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { BaseEntity, Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Category extends BaseEntity{

    @PrimaryGeneratedColumn()
    id: number

    @Column()
    label: string

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.category, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import {Body, Controller, Get, Post} from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm';
import { CategoryRepository } from 'src/category/category.repository';
import { UserRepository } from 'src/user/user.repository';
import { CreatePostDto } from './dto/create-post.dto';
import { PostEntity } from './post.entity';
import { PostService } from './post.service';

@Controller('/post')
@UseGuard(AuthGuard())
export class PostController{
    constructor(private postService: PostService, @InjectRepository(UserRepository) private userRepository: UserRepository, @InjectRepository(CategoryRepository) private categoryRepository: CategoryRepository){}
    @Post('/create')
    async createPost(@Body() createPostDto: CreatePostDto, @getUser: user): Promise<PostEntity>{
        const category1 = await this.categoryRepository.findOne({label: createPostDto.category1})
        const category2 = await this.categoryRepository.findOne({label: createPostDto.category2})
        
        return this.postService.createPost(createPostDto, user, category1, category2)
    }

    @Get()
    async getPost(){
        return this.postService.getPost()
    }
}

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";
import { PostRepository } from "./post.repository";

@Injectable()
export class PostService{
    constructor(@InjectRepository(PostRepository) private postRepository: PostRepository){}

    createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        return this.postRepository.createPost(createPostDto, user, category1, category2)
    }

    async getPost(){
        const post = await this.postRepository.findOne("3")
        return post
    }
}

import { EntityRepository, Repository } from "typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";

@EntityRepository(PostEntity)
export class PostRepository extends Repository<PostEntity>{
    async createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        const {body} = createPostDto
        const post = new PostEntity()
        post.body = body
        post.user = user
        
        post.categoriesPosts = [category1, category2]
        await post.save()
        return post
    }
}

现在

Category

表已经包含了一些值，比如React、Javascript、Python。帖子可以与一个或多个类别相关。因此，在创建帖子时，我也想插入帖子类别。所以我就这么做了。

PostController.ts

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { User } from "src/user/user.entity";
import { BaseEntity, Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity({name: 'post'})
export class PostEntity extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    body: string

    @ManyToOne(() => User, (user: User) => user.posts, {eager: true})
    @JoinColumn({name: 'user_id'})
    user: User

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.post, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { BaseEntity, Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Category extends BaseEntity{

    @PrimaryGeneratedColumn()
    id: number

    @Column()
    label: string

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.category, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import {Body, Controller, Get, Post} from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm';
import { CategoryRepository } from 'src/category/category.repository';
import { UserRepository } from 'src/user/user.repository';
import { CreatePostDto } from './dto/create-post.dto';
import { PostEntity } from './post.entity';
import { PostService } from './post.service';

@Controller('/post')
@UseGuard(AuthGuard())
export class PostController{
    constructor(private postService: PostService, @InjectRepository(UserRepository) private userRepository: UserRepository, @InjectRepository(CategoryRepository) private categoryRepository: CategoryRepository){}
    @Post('/create')
    async createPost(@Body() createPostDto: CreatePostDto, @getUser: user): Promise<PostEntity>{
        const category1 = await this.categoryRepository.findOne({label: createPostDto.category1})
        const category2 = await this.categoryRepository.findOne({label: createPostDto.category2})
        
        return this.postService.createPost(createPostDto, user, category1, category2)
    }

    @Get()
    async getPost(){
        return this.postService.getPost()
    }
}

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";
import { PostRepository } from "./post.repository";

@Injectable()
export class PostService{
    constructor(@InjectRepository(PostRepository) private postRepository: PostRepository){}

    createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        return this.postRepository.createPost(createPostDto, user, category1, category2)
    }

    async getPost(){
        const post = await this.postRepository.findOne("3")
        return post
    }
}

import { EntityRepository, Repository } from "typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";

@EntityRepository(PostEntity)
export class PostRepository extends Repository<PostEntity>{
    async createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        const {body} = createPostDto
        const post = new PostEntity()
        post.body = body
        post.user = user
        
        post.categoriesPosts = [category1, category2]
        await post.save()
        return post
    }
}

PostRepository.ts

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { User } from "src/user/user.entity";
import { BaseEntity, Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity({name: 'post'})
export class PostEntity extends BaseEntity{
    @PrimaryGeneratedColumn()
    id: number

    @Column()
    body: string

    @ManyToOne(() => User, (user: User) => user.posts, {eager: true})
    @JoinColumn({name: 'user_id'})
    user: User

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.post, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import { CategoryPost } from "src/categoryAndPost/category-post.entity";
import { BaseEntity, Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Category extends BaseEntity{

    @PrimaryGeneratedColumn()
    id: number

    @Column()
    label: string

    @OneToMany(() => CategoryPost, categoriesPosts => categoriesPosts.category, {cascade: true})
    categoriesPosts: CategoryPost[]
}

import {Body, Controller, Get, Post} from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm';
import { CategoryRepository } from 'src/category/category.repository';
import { UserRepository } from 'src/user/user.repository';
import { CreatePostDto } from './dto/create-post.dto';
import { PostEntity } from './post.entity';
import { PostService } from './post.service';

@Controller('/post')
@UseGuard(AuthGuard())
export class PostController{
    constructor(private postService: PostService, @InjectRepository(UserRepository) private userRepository: UserRepository, @InjectRepository(CategoryRepository) private categoryRepository: CategoryRepository){}
    @Post('/create')
    async createPost(@Body() createPostDto: CreatePostDto, @getUser: user): Promise<PostEntity>{
        const category1 = await this.categoryRepository.findOne({label: createPostDto.category1})
        const category2 = await this.categoryRepository.findOne({label: createPostDto.category2})
        
        return this.postService.createPost(createPostDto, user, category1, category2)
    }

    @Get()
    async getPost(){
        return this.postService.getPost()
    }
}

import { Injectable } from "@nestjs/common";
import { InjectRepository } from "@nestjs/typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";
import { PostRepository } from "./post.repository";

@Injectable()
export class PostService{
    constructor(@InjectRepository(PostRepository) private postRepository: PostRepository){}

    createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        return this.postRepository.createPost(createPostDto, user, category1, category2)
    }

    async getPost(){
        const post = await this.postRepository.findOne("3")
        return post
    }
}

import { EntityRepository, Repository } from "typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";

@EntityRepository(PostEntity)
export class PostRepository extends Repository<PostEntity>{
    async createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        const {body} = createPostDto
        const post = new PostEntity()
        post.body = body
        post.user = user
        
        post.categoriesPosts = [category1, category2]
        await post.save()
        return post
    }
}

它以如下方式发送响应：

{
    "body": "post 8",
    "user": {
        "id": 1,
        "username": "John"
    },
    "categoryPosts": [
        {
            "id": 4,
            "label": "Javascript"
        },
        {
            "id": 3,
            "label": "React"
        }
    ],
    "id": 10
}

然后在连接表中，post\u id被保存，但category\u id是

null

。

JunctionTable

id    post_id    category_id
 1       10            null
 2       10            null

有人能帮我吗？

由于您正在保存所有类别对象，请按如下方式更改存储库：

PostRepository.ts

import { EntityRepository, Repository } from "typeorm";
import { CreatePostDto } from "./dto/create-post.dto";
import { PostEntity } from "./post.entity";

@EntityRepository(PostEntity)
export class PostRepository extends Repository<PostEntity>{
    async createPost(createPostDto: CreatePostDto, user, category1, category2): Promise<PostEntity>{
        const {body} = createPostDto
        const post = new PostEntity()
        post.body = body
        post.user = user
        
        post.categoriesPosts = [category1.id, category2.id] // Or "post.categoriesPosts = [category1.category_id, category2.category_id]" depend on your dto, it should be id of category
        await post.save()
        return post
    }
}

从“typeorm”导入{EntityRepository，Repository}；
从“/dto/create post.dto”导入{CreatePostDto}”；
从“/post.entity”导入{PostEntity}；
@实体报告（后实体）
导出类PostRepository扩展存储库{
异步createPost（createPostDto:createPostDto，用户，类别1，类别2）：承诺{
const{body}=createPostDto
const post=新的PostEntity（）
post.body=body
post.user=用户
post.categoriesPosts=[category1.id，category2.id]//或“post.categoriesPosts=[category1.category\u id，category2.category\u id]”取决于您的dto，它应该是类别的id
等待post.save（）
回程站
}
}

如果您有两个实体，并且希望通过保存方法保存这两个实体，您可以使用类似的方法（级联：[“插入]）：

Post.entity.ts

  @OneToMany(() => CategoriesPosts, (categoriesPosts) => categoriesPosts.post, {
    eager: false,
    cascade: ['insert'],
  })
  categoriesPosts: categoriesPosts[];

删除您为表和实体指定的自定义名称是否可以解决问题？否。您是否可以创建一个repo或创建一些可以共享的repo，以显示与自定义属性的多对多关系。否。它不起作用。我尝试了所有使用cascade:['insert']，cascade:true的方法，但不知道问题出在哪里，仍然不起作用。您是否可以对具有多对多关系的post和category实体进行简单的crud操作，并以某种方式进行操作，我们可以在其中添加自定义属性，或者您可以克隆并查看我的github存储库。这是回购协议的链接。我用过postgres数据库。当然可以，但给我几个小时