关系列中的空值违反了非空约束 - NestJS

Question

所以。我已经为创建我的项目设置了几乎所有内容。当我尝试在 Postman 中运行它时，我收到标题中指定的错误。相关列是表“Item”中的

cancellation

。在邮递员中，我明确将其定义为 true （不为 null）。同样有趣的是，它不会抱怨

delivery

列，该列与

cancellation

类型完全相同

错误信息：

邮递员截图：

项目实体

import { Category } from './category.entity';
import { Rent } from './rent.entity';
import { User } from './user.entity';
import {
  BaseEntity,
  Column,
  Entity,
  JoinTable,
  ManyToMany,
  ManyToOne,
  OneToOne,
  PrimaryGeneratedColumn,
} from 'typeorm';

@Entity('item')
export class Item {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  description: string;

  @Column()
  price: number;

  @Column()
  delivery: boolean;

  @Column()
  cancellation: boolean;

  @Column({ nullable: true })
  rating: number;

  @Column()
  imageUrl: string;

  @ManyToOne(() => User, (user) => user.items, {
    onDelete: 'CASCADE',
  })
  user: User;

  @OneToOne(() => Rent, (rent) => rent.item)
  rent: Rent;

  @ManyToMany(() => Category, (category) => category.items)
  @JoinTable()
  categories: Category[];
}

创建项目DTO

import {
  IsBoolean,
  IsNotEmpty,
  IsNumber,
  IsOptional,
  IsString,
} from 'class-validator';

export class CreateItemDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsString()
  @IsNotEmpty()
  description: string;

  @IsNumber()
  @IsNotEmpty()
  price: number;

  @IsBoolean()
  @IsNotEmpty()
  delivery: boolean;

  @IsBoolean()
  @IsNotEmpty()
  cancellation: boolean;

  @IsOptional()
  rating: number;

  @IsNotEmpty()
  userId: number;

  @IsOptional()
  imageUrl: string;
}

用户实体

import { Item } from './item.entity';
import { Rent } from './rent.entity';
import { Review } from './review.entity';
import {
  BaseEntity,
  Column,
  Entity,
  OneToMany,
  PrimaryGeneratedColumn,
} from 'typeorm';

@Entity('user')
export class User extends BaseEntity {
  @PrimaryGeneratedColumn()
  id: number;

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

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

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

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

  @Column('varchar', { length: 5 })
  zip: string;

  @Column({ type: 'int', nullable: true })
  rating: number;

  @Column('varchar', { length: 10 })
  phone: string;

  @Column('date')
  date: Date;

  @Column({ type: 'varchar', length: 50, nullable: false, unique: true })
  email: string;

  @Column({ type: 'varchar', length: 75, nullable: false })
  password: string;

  @OneToMany(() => Review, (review) => review.user)
  reviews: Review[];

  @OneToMany(() => Rent, (rent) => rent.user)
  rents: Rent[];

  @OneToMany(() => Item, (item) => item.user)
  items: Item[];
}

物品服务

import { CreateItemDto } from './dto/createItem.dto';
import { ItemsRepository } from './items.repository';
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Item } from 'src/entities/item.entity';
import { User } from 'src/entities/user.entity';

@Injectable()
export class ItemsService {
  constructor(
    @InjectRepository(ItemsRepository)
    private itemsRepository: ItemsRepository,
  ) {}

  async getItemById(id: number) {
    return await this.itemsRepository.findOne(id);
  }

  async createItem(createItemDto: CreateItemDto, user: User): Promise<Item> {
    const newItem = await this.itemsRepository.save({
      name: createItemDto.name,
      description: createItemDto.description,
      price: createItemDto.price,
      delivery: createItemDto.delivery,
      rating: createItemDto.rating,
      imageUrl: createItemDto.imageUrl,
    });

    user.items = [...user.items, newItem];
    await user.save();

    return newItem;
  }
}

物品控制器

import { AuthService } from './../auth/auth.service';
import { CreateItemDto } from './dto/createItem.dto';
import { ItemsService } from './items.service';
import { Body, Controller, Post } from '@nestjs/common';
import { Item } from 'src/entities/item.entity';

@Controller('items')
export class ItemsController {
  constructor(
    private itemsService: ItemsService,
    private authService: AuthService,
  ) {}

  @Post('/createitem')
  async createItem(@Body() createItemDto: CreateItemDto): Promise<Item> {
    const user = await this.authService.getUserById(createItemDto.userId);
    return this.itemsService.createItem(createItemDto, user);
  }
}

认证服务

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { SignUpDto } from './dto/signup.dto';
import { SignInDto } from './dto/signin.dto';
import { UsersRepository } from './users.repository';
import * as bcrypt from 'bcrypt';
import { JwtService } from '@nestjs/jwt';
import { JwtPayload } from './jwt-payload.interface';
import { User } from 'src/entities/user.entity';

@Injectable()
export class AuthService {
  constructor(
    @InjectRepository(UsersRepository)
    private usersRepository: UsersRepository,
    private jwtService: JwtService,
  ) {}

  async signUp(signUpDto: SignUpDto): Promise<void> {
    return this.usersRepository.createUser(signUpDto);
  }

  async signIn(signInDto: SignInDto): Promise<{ accessToken: string }> {
    const { email, password } = signInDto;
    const user = await this.usersRepository.findOne({ email });
    if (user && (await bcrypt.compare(password, user.password))) {
      const payload: JwtPayload = { email };
      const accessToken: string = await this.jwtService.sign(payload);
      return { accessToken };
    } else {
      throw new UnauthorizedException('Check your login credentials');
    }
  }
  async getUserById(id: number): Promise<User> {
    return await this.usersRepository.findOne(id, { relations: ['items'] });
  }
}

物品模块

import { AuthModule } from './../auth/auth.module';
import { AuthService } from './../auth/auth.service';
import { ItemsRepository } from './items.repository';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Module } from '@nestjs/common';
import { ItemsController } from './items.controller';
import { ItemsService } from './items.service';

@Module({
  imports: [TypeOrmModule.forFeature([ItemsRepository]), AuthModule],
  controllers: [ItemsController],
  providers: [ItemsService],
})
export class ItemsModule {}

Answer 1

您忘记添加

cancellation

属性：

    const newItem = await this.itemsRepository.save({
  name: createItemDto.name,
  description: createItemDto.description,
  price: createItemDto.price,
  delivery: createItemDto.delivery,
  rating: createItemDto.rating,
  imageUrl: createItemDto.imageUrl,
  cancellation: createItemDto.cancellation, // this one
});

Answer 2

如果您在 Nestjs 项目中添加了实体之间的一对多关系。

用户 1-->* 任务

用户.实体.ts

@Entity()
export class User {

  @PrimaryGeneratedColumn()
  id: number;

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

  @Column()
  password: string;

  @Column({ unique: true})
  email: string;

  @OneToMany(() => Task, (task) => task.user)
  @JoinColumn({ name: 'id', referencedColumnName: 'userId'})
  tasks: Task[];

}

任务.实体.ts

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

  // @Column({ unique: true})
  @Column('text')
  description: string;

  @Column({ type: 'enum', enum: TaskStatus, default: TaskStatus.OPEN})
  status: TaskStatus;

  @Column({ name: 'created_at', type: 'timestamp', default: () => 'CURRENT_TIMESTAMP'})
  date: Date;

  @DeleteDateColumn({ name: 'deleted_at', type: 'timestamp', nullable: true })
  deletedAt: Date;

  @Column({ name: 'user_id'})
  userId: number;

  @ManyToOne(() => User, (user) => user.tasks)
  @JoinColumn({ name: 'userId'})
  user: User;
}

可以删除数据库中每个表的所有数据。

delete from user;
delete from task ;

Answer 3

使用 x-www-form-data 在邮递员中发布用户名密码