Express+Sequelize+PostgreSQL如何自动填充数据库表初始值？

我基于Express框架搭建应用，采用PostgreSQL作为数据库、Sequelize作为ORM。现有数据库连接、模型定义代码如下，需要实现数据库表初始化时自动填充标准值——比如给message_types表填充Default、Deleted、System、Voice、Video这些固定值，同时附上了当前的实现方式，寻求更规范或更优的解决方案。

现有代码 #

数据库连接代码 #

import { Sequelize } from "sequelize-typescript";
import "dotenv/config";

export const sequelize = new Sequelize({
    database: process.env.DB_NAME,
    dialect: "postgres",
    username: process.env.DB_USERNAME,
    password: process.env.DB_PASSWORD,
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    models: [__dirname + "/models/**"]
});

MessageType模型定义 #

import { Table, Column, Model, DataType, ForeignKey, HasMany } from 'sequelize-typescript';

import Message from './Message';

@Table({
    timestamps: false,
    tableName: "message_types"
})
class MessageType extends Model {
    @Column({
        type: DataType.STRING,
    })
    type: string;

    @HasMany(() => Message, {
        onDelete: 'CASCADE'
    })
    messages: Message[];
}

export default MessageType;

当前实现的初始化方法 #

import { Op } from "sequelize";

import MessageType from "../../db/models/messenger/MessageType";
import { MessageTypes } from "types/messenger";

const initialTypes: string[] = [
    MessageTypes.Default,
    MessageTypes.Deleted,
    MessageTypes.System,
    MessageTypes.Voice,
    MessageTypes.Video
];

class MessageTypeService {
    async initMessageTypes() {
        initialTypes.forEach(async (type) => {
            const existedType = await MessageType.findOne({
                where: {
                    type
                }
            });

            if (!existedType) {
                await MessageType.create({
                    type
                });
            }
        });

        return await MessageType.destroy({
            where: {
                type: {
                    [Op.notIn]: initialTypes
                }
            }
        });
    }
}

export default new MessageTypeService();

1. 修复当前实现的异步问题 #

你当前代码里的forEach循环嵌套async/await会导致创建操作并行执行但无法被正确等待，可能出现删除操作先完成、部分创建操作还未执行的情况，引发数据不一致。可以改成用Promise.all统一等待所有创建操作：

async initMessageTypes() {
    // 等待所有创建/检查操作完成
    await Promise.all(initialTypes.map(async (type) => {
        await MessageType.findOrCreate({ where: { type } });
    }));

    // 再执行非初始值的删除操作
    return await MessageType.destroy({
        where: {
            type: { [Op.notIn]: initialTypes }
        }
    });
}

这里直接用findOrCreate替代“查询+判断+创建”的逻辑，代码更简洁。

2. 使用Sequelize官方Seeders（种子文件） #

Sequelize自带的Seeders是更规范的基础数据初始化方案，适合这类固定枚举值的填充，步骤如下：

步骤1：生成种子文件 #

在项目根目录执行命令：

npx sequelize-cli seed:generate --name init-message-types

步骤2：编辑种子文件 #

在项目的seeds目录找到生成的文件，修改内容为：

import { QueryInterface } from 'sequelize';
import { MessageTypes } from '../types/messenger';

const initialTypes = [
    MessageTypes.Default,
    MessageTypes.Deleted,
    MessageTypes.System,
    MessageTypes.Voice,
    MessageTypes.Video
];

module.exports = {
    async up(queryInterface: QueryInterface) {
        // 批量插入不存在的初始值
        const [existingTypes] = await queryInterface.sequelize.query(
            'SELECT type FROM message_types'
        );
        const existingTypeNames = (existingTypes as Array<{type: string}>).map(item => item.type);
        const typesToInsert = initialTypes.filter(type => !existingTypeNames.includes(type));
        
        if (typesToInsert.length > 0) {
            await queryInterface.bulkInsert('message_types', typesToInsert.map(type => ({ type })));
        }

        // 删除不在初始列表中的数据
        await queryInterface.bulkDelete('message_types', {
            type: { [queryInterface.sequelize.Op.notIn]: initialTypes }
        });
    },

    async down(queryInterface: QueryInterface) {
        // 回滚时删除所有初始数据
        await queryInterface.bulkDelete('message_types', {
            type: { [queryInterface.sequelize.Op.in]: initialTypes }
        });
    }
};

步骤3：执行种子文件 #

• 手动执行：

npx sequelize-cli db:seed:all

• 应用启动时自动执行：
  在数据库连接验证通过后调用种子命令：

import { sequelize } from './path/to/sequelize';
import { exec } from 'child_process';

sequelize.authenticate().then(() => {
    exec('npx sequelize-cli db:seed:all', (err, stdout, stderr) => {
        if (err) {
            console.error('数据初始化失败:', stderr);
            return;
        }
        console.log('基础数据初始化完成:', stdout);
        // 启动Express服务
    });
});

3. 模型层面添加同步钩子 #

如果希望每次模型同步（sequelize.sync()）时都自动保证数据存在，可以在MessageType模型中添加afterSync钩子：

import { Op } from "sequelize";
import { MessageTypes } from "../types/messenger";

@Table({
    timestamps: false,
    tableName: "message_types"
})
class MessageType extends Model {
    @Column({
        type: DataType.STRING,
    })
    type: string;

    @HasMany(() => Message, {
        onDelete: 'CASCADE'
    })
    messages: Message[];

    // 同步完成后自动初始化数据
    static afterSync = async () => {
        const initialTypes = [
            MessageTypes.Default,
            MessageTypes.Deleted,
            MessageTypes.System,
            MessageTypes.Voice,
            MessageTypes.Video
        ];

        await Promise.all(initialTypes.map(type => 
            MessageType.findOrCreate({ where: { type } })
        ));

        await MessageType.destroy({
            where: { type: { [Op.notIn]: initialTypes } }
        });
    };
}

这样每次执行sequelize.sync()时，都会自动触发数据初始化逻辑。

内容的提问来源于stack exchange，提问作者w1nchester