Sequelize动态模型创建求助：调用模型返回undefined

核心问题 #

你定义的模型文件导出了一个异步函数，但Sequelize默认的模型加载逻辑是同步执行的，不会等待异步操作完成。这就导致models.result实际上是一个未被解析的Promise对象（甚至可能因为异步报错直接返回undefined），而非初始化后的Model实例。

解决方案 #

方案一：改为异步加载模型 #

调整models/index.js的加载逻辑，使其支持异步加载模型：

const fs = require('fs');
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(__filename);
const env = process.env.NODE_ENV || 'development';
const config = require(__dirname + '/../config/config.json')[env];
const db = {};

let sequelize;
if (config.use_env_variable) {
  sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
  sequelize = new Sequelize(config.database, config.username, config.password, config);
}

// 异步加载所有模型
async function loadModels() {
  const modelFiles = fs
    .readdirSync(__dirname)
    .filter(file => 
      file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js'
    );

  for (const file of modelFiles) {
    const modelFactory = require(path.join(__dirname, file));
    // 等待异步模型工厂执行完成
    const model = await modelFactory(sequelize, Sequelize.DataTypes);
    db[model.name] = model;
  }

  // 关联模型（如果有）
  Object.keys(db).forEach(modelName => {
    if (db[modelName].associate) {
      db[modelName].associate(db);
    }
  });

  db.sequelize = sequelize;
  db.Sequelize = Sequelize;
  return db;
}

// 导出加载模型的Promise
module.exports = loadModels();

然后修改你的Dao文件，等待模型加载完成后再使用：

const SuperDao = require('./SuperDao');
const loadModels = require('../models');

class ResultDao extends SuperDao {
  constructor(model) {
    super(model);
  }

  async uploadBulkResult(data) {
    return this.model.bulkCreate(data);
  }
}

// 导出异步初始化方法
async function initResultDao() {
  const models = await loadModels();
  return new ResultDao(models.result);
}

module.exports = initResultDao;

在使用Dao的地方，需要先等待初始化完成：

const initResultDao = require('./ResultDao');

async function processData(data) {
  const resultDao = await initResultDao();
  await resultDao.uploadBulkResult(data);
}

方案二：提前缓存字段信息（同步加载模型） #

如果希望保持模型同步加载，可以提前查询字段信息并缓存到本地文件，模型直接读取缓存内容：

1. 编写预加载脚本scripts/preload-columns.js：

const sequelize = require('../models/sequelize'); // 引入你的Sequelize实例
const fs = require('fs');

async function preloadColumns() {
  try {
    const query = `SELECT COLUMN_NAME AS columnName
      FROM INFORMATION_SCHEMA.COLUMNS
      WHERE TABLE_NAME = 'results';`;
    const [columns] = await sequelize.query(query);
    
    const columnConfig = columns.reduce((acc, cur) => {
      if (cur.columnName !== 'id') {
        acc[cur.columnName] = {
          type: 'STRING',
          allowNull: true
        };
      }
      return acc;
    }, {
      roll: {
        type: 'INTEGER',
        allowNull: false
      }
    });

    fs.writeFileSync('./models/result-columns.json', JSON.stringify(columnConfig));
    console.log('字段信息缓存成功');
    process.exit(0);
  } catch (err) {
    console.error('字段预加载失败:', err);
    process.exit(1);
  }
}

preloadColumns();

2. 修改模型文件为同步加载：

const columnConfig = require('./result-columns.json');

module.exports = (sequelize, DataTypes) => {
  class Result extends Model {}

  // 将缓存的类型字符串映射为DataTypes实例
  const mappedColumns = Object.entries(columnConfig).reduce((acc, [key, config]) => {
    acc[key] = {
      ...config,
      type: DataTypes[config.type]
    };
    return acc;
  }, {});

  Result.init(mappedColumns, {
    sequelize,
    modelName: 'result',
    underscored: false
  });

  return Result;
};

3. 启动项目前先执行预加载脚本：

node scripts/preload-columns.js

额外排查点 #

• 检查getColumn函数中的数据库查询是否有权限访问INFORMATION_SCHEMA.COLUMNS
• 确认表名results是否与数据库中实际表名一致（注意大小写敏感问题）
• 在getColumn中添加错误捕获，排查是否有查询失败的情况

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