用于 Sequelize v5 和 Typescript 的模型加载器

Question

用于 Sequelize v5 和 Typescript 的模型加载器

ndy*_*dyr 4 express sequelize.js typescript

之前在项目 ( v4 ) 中使用过 Sequelize，但尝试使用 Sequelize v5 和 Typescript 开始一个新项目

我已经按照 Sequelize 的文档了解如何定义模型：https ://sequelize.org/master/manual/typescript.html#usage-of--code-sequelize-define--code-

我现在有一个可用的 ORM，但仅在导入实际模型以供使用时，而不是通过从模型加载器导入数据库。
IEimport { User } from "../db/models/user";

导入数据库，在尝试访问 db.User 时只返回undefined。

试图弄清楚如何让模型加载器与 Sequelize V5 和 Typescript 完美搭配，但目前它是空的。

现在，我可以说它正在搜索.js文件。所以显然它不会获取 user.ts 文件。将其更改为.ts然后给我错误....

    at Sequelize.import (/node_modules/sequelize/lib/sequelize.js:486:38)
    at fs_1.default.readdirSync.filter.forEach.file (/src/db/models/index.ts:26:35)
    at Array.forEach (<anonymous>)
    at Object.<anonymous> (/src/db/models/index.ts:25:4)

Run Code Online (Sandbox Code Playgroud)

我一直试图从网络搜索中获得明确的答案，但似乎是空洞的。试图让一切都玩得很好，这已经够头疼了……此时我正在将迁移/播种机作为 js 文件运行，因为我不想处理sequelize-typescript-cli或sequelize-typescript

src/db/models/user.ts 用户模型

import { Sequelize, Model, DataTypes, BuildOptions } from 'sequelize';
import { HasManyGetAssociationsMixin, HasManyAddAssociationMixin, HasManyHasAssociationMixin, Association, HasManyCountAssociationsMixin, HasManyCreateAssociationMixin } from 'sequelize';
const db = require('./index')
import * as bcrypt from "bcryptjs";

export interface UserAttributes extends Model {
  id: string;
  email: string;
  username: string;
  password: string;
  createdAt: Date;
  updatedAt: Date;
  validatePassword(password: string): boolean;
  generateHash(password: string): string;
}

export type UserModel = typeof Model & {
  new (): UserAttributes;
};

export const User = <UserModel>db.sequelize.define("User", {
  id: {
    type: DataTypes.UUID,
    allowNull: false,
    primaryKey: true
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true
  },
  username: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true
  },
  password: {
    type: DataTypes.STRING,
    allowNull: false,
  }
},
{
  tableName: "User",
  freezeTableName: true,
 });

 User.prototype.validatePassword = function (password: string) {

  return bcrypt.compareSync(password, this.password)
 }

 User.prototype.generateHash = function (password: string) {
    return bcrypt.hashSync(password, bcrypt.genSaltSync(10))
  }

Run Code Online (Sandbox Code Playgroud)

src/db/models/index.ts 模型加载器

'use strict';

import fs from "fs";
const path = require('path');
const Sequelize = require('sequelize');
const basename = path.basename(module.filename);

const env = process.env.NODE_ENV || 'development';
const config = require(`${__dirname}/../config/config.json`)[env];

interface DB {
  [key: string]: any;
}

var db: DB = {};

const sequelize = new Sequelize(config.database, config.username, config.password, config);

fs.readdirSync(__dirname)
  .filter(file => {
    return (
      file.indexOf(".") !== 0 && file !== basename && file.slice(-3) === ".js"
    );
  })
  .forEach(file => {
    const model = sequelize.import(path.join(__dirname, file));
    db[model.name] = model;
  });
// Important: creates associations based on associations defined in associate function in the model files
Object.keys(db).forEach(modelName => {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

Run Code Online (Sandbox Code Playgroud)

进一步阅读https://sequelize.org/master/manual/typescript.html#usage

定义模型似乎更清晰（但有点多余），但是当从 index.js 初始化 Sequelize 时，这个init方法是如何调用的？

Answer 1

ndy*_*dyr 5

所以我让它工作了，但是在一个非循环模型加载器中。我忽略了定义文档， https://sequelize.org/master/manual/typescript.html#usage-of--code-sequelize-define--code-

对于这里冗长的课堂方法： https //sequelize.org/master/manual/typescript.html#usage

我将完成设置 2 个模型及其关联的过程，希望能帮助那些试图将 Typescript 与 Sequelize v5 集成的人。

肯定会喜欢这种方法的反馈。

让我们从用户和相关身份（用于访问 API）的类开始

/src/db/models/user.ts

import { Sequelize, Model, DataTypes, BuildOptions } from 'sequelize';
import { Association, HasManyGetAssociationsMixin, HasManyAddAssociationMixin, HasManyHasAssociationMixin, HasManyCountAssociationsMixin, HasManyCreateAssociationMixin } from 'sequelize';
import { Identity } from './identity';
export class User extends Model {
  public id!: string; // Note that the `null assertion` `!` is required in strict mode.
  public active!: boolean;

  // timestamps!
  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;

  public getIdentities!: HasManyGetAssociationsMixin<Identity>; // Note the null assertions!
  public addIdentity!: HasManyAddAssociationMixin<Identity, number>;
  public hasIdentity!: HasManyHasAssociationMixin<Identity, number>;
  public countIdentities!: HasManyCountAssociationsMixin;
  public createIdentity!: HasManyCreateAssociationMixin<Identity>;

  // You can also pre-declare possible inclusions, these will only be populated if you
  // actively include a relation.
  public readonly identities?: Identity[]; // Note this is optional since it's only populated when explicitly requested in code

  public static associations: {
    identities: Association<User, Identity>;
  };

}

export function initUser(sequelize: Sequelize): void {
  User.init({
    id: {
      type: DataTypes.UUID,
      primaryKey: true,
    },
    active: {
      type:DataTypes.BOOLEAN,
      defaultValue: true,
      allowNull: false
    }
  }, {
    tableName: 'User', 
    sequelize: sequelize, // this bit is important
  });


}

export function associateUser(): void {
  // Here we associate which actually populates out pre-declared `association` static and other methods.
  User.hasMany(Identity, {
    sourceKey: 'id',
    foreignKey: 'UserId',
    as: 'identities' // this determines the name in `associations`!
  });
}

Run Code Online (Sandbox Code Playgroud)

/src/db/models/identity.ts

import { Sequelize, Model, DataTypes, BuildOptions } from 'sequelize';
import { Association, HasOneGetAssociationMixin, HasOneCreateAssociationMixin } from 'sequelize';
import { User } from './user'

import * as bcrypt from "bcryptjs";

export class Identity extends Model {
  public id!: string; // Note that the `null assertion` `!` is required in strict mode.
  public username!: string;
  public password!: string;
  public UserId: string;
  public active!: boolean;

  // timestamps!
  public readonly createdAt!: Date;
  public readonly updatedAt!: Date;

  public getUser!: HasOneGetAssociationMixin<User>; // Note the null assertions!

  // You can also pre-declare possible inclusions, these will only be populated if you
  // actively include a relation.
  public readonly user?: User; // Note this is optional since it's only populated when explicitly requested in code

  public static associations: {
    user: Association<Identity, User>;
  };

  public validatePassword(password: string) : boolean {
    return bcrypt.compareSync(password, this.password)
  }
}

export function initIdentity(sequelize: Sequelize): void {
  Identity.init({
    id: {
      type: DataTypes.UUID,
      primaryKey: true,
    },
    username: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false
    },
    UserId: {
      type: DataTypes.UUID,
      allowNull: true
    },
    active: {
      type:DataTypes.BOOLEAN,
      defaultValue: true,
      allowNull: false
    }
  }, {
    tableName: 'Identity', 
    sequelize: sequelize, // this bit is important
  });

}

export function associateIdentity(): void {
  // Here we associate which actually populates out pre-declared `association` static and other methods.
  Identity.belongsTo(User, {targetKey: 'id'});
}

Run Code Online (Sandbox Code Playgroud)

因此，在此之后，我们声明了所有与 Sequelize 和数据库相关的“虚拟”成员和函数。此外还有init<model>&&associate<model>函数，用于将所有内容联系在一起。

注意您可能会注意到，在中identity.ts，关联中使用的是 UserId 而不是 userId。出于某种原因，它一直假设关联将通过 UserId，即使我使用了 userId。在进行查询时，它抱怨没有列 UserId （但是 userId ）。因此，将其更新为大写的“U”解决了它。 我不确定为什么此时会这样做。

现在把这一切联系在一起

/src/db/index.ts

import { initUser, associateUser } from "./user";
import { initIdentity, associateIdentity } from "./identity";

const Sequelize = require('sequelize');

const env = process.env.NODE_ENV || 'development';
const config = require(`${__dirname}/../config/config.json`)[env];


interface DB {
  [key: string]: any;
}

const sequelize = new Sequelize(config.database, config.username, config.password, config);

initUser(sequelize);
initIdentity(sequelize)

associateUser();
associateIdentity();

const db = {
  sequelize,
  Sequelize,
  User: sequelize.models.User,
  Identity: sequelize.models.Identity
}

module.exports = db;

Run Code Online (Sandbox Code Playgroud)

通常要做的模型加载，进入目录，找到所有模型，然后将它们导入sequelize。现在就像我之前说的，define在尝试通过这个模型加载器时尝试在模型类中使用会导致问题，因为非 Typescript 版本总是寻找 *.js 而不是 *.ts。更改为 *.ts 使一切崩溃define通话中的。（更不用说因为所有这些代码都将被转换为 js 文件，这不会导致问题反过来吗？）

但是正如你所看到的，我是手工做的，而不是循环的。可能有更好的循环方式来做到这一点，但目前这已经足够了。

这些模型在 sequelize 中通过调用它们的init<model>函数进行初始化。初始化后，它们的关联是通过调用associate<model>

在启动我的快速服务器之前，我需要索引文件，这一切都开始了。繁荣。

关于我的方法的其他注意事项我 不想安装比我需要的更多的软件包。所以我避开了 sequelize-typescript 和 sequelize-typescript-cli。这意味着我所有的播种机文件和迁移文件都需要手工制作而不使用 cli（它真的没那么糟糕）并且不是 *.ts 而是 *.js。

例子： 20191017135846-create-identity.js

'use strict'
module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable({tableName:'Identity'}, {
      id: {
        type: Sequelize.UUID,
        defaultValue: Sequelize.UUIDV4,
        allowNull: false,
        autoIncrement: false,
        primaryKey: true,
      },
      username: {
        type: Sequelize.STRING,
        allowNull: false,
        unique: true,
      },
      password: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      UserId: {
        type: Sequelize.UUID,
        references: {
          model: 'User', // name of Target model
          key: 'id', // key in Target model that we're referencing
        },
        onUpdate: 'CASCADE',
        onDelete: 'SET NULL',
      },
      active: {
        type: Sequelize.BOOLEAN,
        defaultValue: true,
        allowNull: false,
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.NOW
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE,
        defaultValue: Sequelize.NOW
      },
    })
  },
  down: (queryInterface) => {
    return queryInterface.dropTable({tableName:'Identity', schema:'public'})
  }
}

Run Code Online (Sandbox Code Playgroud)

20191015141822-seed-users.js

'use strict'
var moment = require('moment');
var uuidv4 = require('uuid/v4');
const bcrypt = require('bcryptjs');

module.exports = {
  up: async (queryInterface) => {   
      // User
      const user1Id = uuidv4();
      await queryInterface.bulkInsert('User', 
        [
          {
            id:user1Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )
      await queryInterface.bulkInsert('Identity', 
        [
          {
            id:uuidv4(),
            username: "user1",
            password: bcrypt.hashSync('password', bcrypt.genSaltSync(10)),
            UserId: user1Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )

      const user2Id = uuidv4();
      await queryInterface.bulkInsert('User', 
        [
          {
            id:user2Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )
      await queryInterface.bulkInsert('Identity', 
        [
          {
            id:uuidv4(),
            username: "user2",
            password: bcrypt.hashSync('password', bcrypt.genSaltSync(10)),
            UserId: user2Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )

      const user3Id = uuidv4();
      await queryInterface.bulkInsert('User', 
        [
          {
            id:user3Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )
      await queryInterface.bulkInsert('Identity', 
        [
          {
            id:uuidv4(),
            username: "user3",
            password: bcrypt.hashSync('password', bcrypt.genSaltSync(10)),
            UserId: user3Id,
            createdAt: new Date( moment.utc().format() ), 
            updatedAt: new Date( moment.utc().format() )
          }
        ], 
      )


  },
  down: async (queryInterface) => {
    await queryInterface.bulkDelete({ tableName: 'User'}, null, {})
  }
}

Run Code Online (Sandbox Code Playgroud)

此时您可以运行

sequelize db:migrate
sequelize db:seed:all

Run Code Online (Sandbox Code Playgroud)

并且一切正常并且可以访问数据库。

现在使用类/打字稿我注意到将模型添加到导出的 db 对象是多余的....

我可以通过导入访问所需的模型

import { User } from '../db/models/user' 或 require('./db/models/index')

然后我可以执行 User.findAll() 或使用其他导入 db.User.findAll()

归档时间：	5 年，10 月前
查看次数：	4493 次
最近记录：	5 年，10 月前