postgresql - 迁移未在终端中运行，但在数据库中运行

Question

正在开发的应用程序，使用 Postgres、docker 和 typeorm。终端射击错误，好像没有运行迁移，并说“关系'孤儿院'已经存在”。

但是我的数据库客户端工具 beekeper 显示所有迁移都创建得很好，并且 api 在所有路由中都正常接收数据。

有人知道发生了什么吗？

ormconfig.json

  {
    "type": "postgres",
    "host": "localhost",
    "port": 5432,
    "username": "postgres",
    "password": "docker",
    "database": "happy",
    "synchronize": true,
    "migrations": [
      "./src/database/migrations/*.ts"
    ],
    "entities": [
      "./src/models/*.ts"
    ],
    "cli": {
      "migrationsDir": "./src/database/migrations"
    }

  }

迁移文件：

import {MigrationInterface, QueryRunner, Table} from "typeorm";

export class Orphanage1616788509901 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.createTable(new Table({
            name: 'orphanages',
            columns: [
                {
                    name: 'id',
                    type: 'uuid',
                    unsigned: true,
                    isPrimary: true,
                    isGenerated: true,
                
                },
                {
                    name: 'name',
                    type: 'varchar'
                },
                {
                    name: 'latitude',
                    type: 'varchar'        
                },
                {
                    name: 'longitude',
                    type: 'varchar'
                },
                {
                    name: 'about',
                    type: 'text'
                },
                {
                    name: 'instructions',
                    type: 'text'
                },
                {
                    name: 'opening_hours',
                    type: 'varchar'
                },
                {
                    name: 'open_on_weekends',
                    type: 'boolean',
                    default: 'false'
                },
                {
                    name: 'user_name',
                    type: 'varchar'
                },
                {
                    name: 'user_id',
                    type: 'uuid'
                }

            ],
            foreignKeys: [
                {
                    name: 'OrphanageUser',
                    columnNames: ['user_id'],
                    referencedTableName: 'users',
                    referencedColumnNames: ['id'],
                    onUpdate: 'CASCADE',
                    onDelete: 'CASCADE',
                }
            ]
        }))
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.dropTable('orphanages');
    }

}

实体文件

import { Entity, Column, PrimaryGeneratedColumn, OneToMany, JoinColumn, ManyToOne } from 'typeorm';
import Image from './Images';
import User from './User';

@Entity('orphanages')  
export default class Orphanage {
    @PrimaryGeneratedColumn('uuid')
    id: number;

    @Column()
    name: string;

    @Column()
    latitude: string;

    @Column()
    longitude: string;

    @Column()
    about: string;

    @Column()
    instructions: string;

    @Column()
    opening_hours: string;

    @Column()
    open_on_weekends: boolean;

    @Column()
    user_id: number;

    @Column()
    user_name: string;   

    @OneToMany(() => Image, image => image.orphanage, {
    cascade: ['insert' , 'update']
    })
    @JoinColumn({ name: 'orphanage_id'})  
    images: Image[];


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


}

用户迁移文件

import {MigrationInterface, QueryRunner, Table} from "typeorm";

export class User1616788592127 implements MigrationInterface {

    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.createTable(new Table({
            name: 'users',            
            columns: [
                {
                    name: 'id',
                    type: 'uuid',
                    unsigned: true,
                    isPrimary: true,
                    isGenerated: true,
                    // generationStrategy:'increment'
                    
                },
                {
                    name: 'name',
                    type: 'varchar'
                },
                {
                    name: 'email',
                    type: 'varchar',
                    isUnique: true
                },
                {
                    name: 'password',
                    type: 'varchar',
                },
                {
                    name: 'role',
                    type: 'varchar',
                },     
                {
                    name: "date",
                    type: "timestamp",
                },
                {
                    name: "isVerified",
                    type: "boolean",
                    default: false,
                },    
                {
                    name: "tokenId",
                    type: "uuid",
                    // default: false,
                }, 
            ],
            foreignKeys: [
                {
                    name: 'TokenUser',
                    columnNames: ['tokenId'],
                    referencedTableName: 'tokens',
                    referencedColumnNames: ['id'],
                    onUpdate: 'CASCADE',
                    onDelete: 'CASCADE',
                }
            ]

            
 
        }))
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.dropTable('users');
    }

}

用户实体文件

import { Request, Response } from 'express';
import { Entity, Column, PrimaryGeneratedColumn, BeforeInsert, BeforeUpdate, OneToMany, OneToOne, JoinColumn, CreateDateColumn, UpdateDateColumn, createConnection } from 'typeorm'; // decorators from typeorm
// import { Length, IsNotEmpty } from 'class-validator';
import * as bcrypt from 'bcryptjs';
import Orphanage from './Orphanage';
import Token from './Token';


@Entity('users') 
export default class User {
   
    @PrimaryGeneratedColumn('uuid')
    id: number;

    @Column()
    name: string;

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

    @Column()
    password: string;
  
    @Column()
    role: string;
    default: 'basic'
    enum: ["basic", "supervisor", "admin"];



    @Column({
      type: "timestamp"
    })
    date!: Date;

    @Column({
      default: false
    })
    isVerified: boolean;

       
    checkIfUnencryptedPasswordIsValid(unencryptedPassword: string) {
      return bcrypt.compareSync(unencryptedPassword, this.password);
    }


    @OneToMany(() => Orphanage, orphanage => orphanage.user, {
        cascade: ['insert' , 'update']
    })     
    @JoinColumn({ name: 'user_id'}) 
    orphanages: Orphanage[];

    @OneToOne(() => Token, token => token.user, {
      // cascade: ['insert' , 'update'] //
    }) 
    @JoinColumn({name: "tokenId"})
    // token: Token[];
    token: Token;
    


    
}

标签： postgresqldockertypeorm