TypeScript

从v5开始,Sequelize 提供了自己的 TypeScript 定义. 请注意,仅支持 TS >= 3.1.

由于 Sequelize 严重依赖于运行时属性赋值,因此 TypeScript 在开箱即用时不会非常有用. 需要大量的手动类型声明才能使模型可用.

安装

为了避免非 TS 用户的安装膨胀,你必须手动安装以下键入包:

  • @types/node (这是普遍需要的)
  • @types/validator
  • @types/bluebird

使用

最简 TypeScript 项目示例:

  1. import { Sequelize, Model, DataTypes, BuildOptions } from 'sequelize';
  2. import { HasManyGetAssociationsMixin, HasManyAddAssociationMixin, HasManyHasAssociationMixin, Association, HasManyCountAssociationsMixin, HasManyCreateAssociationMixin } from 'sequelize';
  4. class User extends Model {
  5.   public id!: number; // 注意在严格模式下需要 `null assertion` 或 `！`.
  6.   public name!: string;
  7.   public preferredName!: string | null; // 可以为空的字段
  9.   // 时间戳!
  10.   public readonly createdAt!: Date;
  11.   public readonly updatedAt!: Date;
  13.   // 由于TS无法在编译时确定模型关联,
  14.   // 因此我们必须在这里声明它们,
  15.   // 实际上这些在调用`Model.init`之前不会存在.
  17.   public getProjects!: HasManyGetAssociationsMixin<Project>; // 注意空断言！
  18.   public addProject!: HasManyAddAssociationMixin<Project, number>;
  19.   public hasProject!: HasManyHasAssociationMixin<Project, number>;
  20.   public countProjects!: HasManyCountAssociationsMixin;
  21.   public createProject!: HasManyCreateAssociationMixin<Project>;
  23.   // 你还可以预先声明可能的包含,
  24.   // 只有在你主动包含关系时才会填充这些包含.
  25.   public readonly projects?: Project[]; // 请注意,这是可选的,因为它仅在代码中明确请求时填充
  27.   public static associations: {
  28.     projects: Association<User, Project>;
  29.   };
  30. }
  32. const sequelize = new Sequelize('mysql://root:asd123@localhost:3306/mydb');
  34. class Project extends Model {
  35.   public id!: number;
  36.   public ownerId!: number;
  37.   public name!: string;
  39.   public readonly createdAt!: Date;
  40.   public readonly updatedAt!: Date;
  41. }
  43. class Address extends Model {
  44.   public userId!: number;
  45.   public address!: string;
  47.   public readonly createdAt!: Date;
  48.   public readonly updatedAt!: Date;
  49. }
  51. Project.init({
  52.   id: {
  53.     type: DataTypes.INTEGER.UNSIGNED, // 你可以省略 `new` 但不鼓励这样做
  54.     autoIncrement: true,
  55.     primaryKey: true,
  56.   },
  57.   ownerId: {
  58.     type: DataTypes.INTEGER.UNSIGNED,
  59.     allowNull: false,
  60.   },
  61.   name: {
  62.     type: new DataTypes.STRING(128),
  63.     allowNull: false,
  64.   }
  65. }, {
  66.   sequelize,
  67.   tableName: 'projects',
  68. });
  70. User.init({
  71.   id: {
  72.     type: DataTypes.INTEGER.UNSIGNED,
  73.     autoIncrement: true,
  74.     primaryKey: true,
  75.   },
  76.   name: {
  77.     type: new DataTypes.STRING(128),
  78.     allowNull: false,
  79.   },
  80.   preferredName: {
  81.     type: new DataTypes.STRING(128),
  82.     allowNull: true
  83.   }
  84. }, {
  85.   tableName: 'address',
  86.   sequelize: sequelize, // 这一点很重要
  87. });
  89. Address.init({
  90.   userId: {
  91.     type: DataTypes.INTEGER.UNSIGNED,
  92.   },
  93.   address: {
  94.     type: new DataTypes.STRING(128),
  95.     allowNull: false,
  96.   }
  97. }, {
  98.   tableName: 'users',
  99.   sequelize: sequelize, // 这一点很重要
  100. });
  102. // 在这里,我们关联实际填充预先声明的 `association` 静态方法和其他方法.
  103. User.hasMany(Project, {
  104.   sourceKey: 'id',
  105.   foreignKey: 'ownerId',
  106.   as: 'projects' // 这确定了 `associations` 中的名字！
  107. });
  109. Address.belongsTo(User, {targetKey: 'id'});
  110. User.hasOne(Address,{sourceKey: 'id'});
  112. async function stuff() {
  113.   // 请注意,当使用 async/await 时,你将丢失`bluebird` promise上下文,
  114.   // 然后你将回到本地
  115.   const newUser = await User.create({
  116.     name: 'Johnny',
  117.     preferredName: 'John',
  118.   });
  119.   console.log(newUser.id, newUser.name, newUser.preferredName);
  121.   const project = await newUser.createProject({
  122.     name: 'first!',
  123.   });
  125.   const ourUser = await User.findByPk(1, {
  126.     include: [User.associations.projects],
  127.     rejectOnEmpty: true, // 在这里指定 true 会从返回类型中删除`null`！
  128.   });
  129.   console.log(ourUser.projects![0].name); // 注意`！` null 断言,
  130.                                           // 因为TS无法知道我们是否包含了模型
  131. }

sequelize.define 的用法

当我们使用 sequelize.define 方法定义模型时,TypeScript 不知道如何生成 class 定义. 因此,我们需要做一些手动操作并声明一个接口和一个类型,并最终将 .define 的结果转换为 static 类型.

  1. // 我们需要为我们的模型声明一个接口,基本上就是我们的类
  2. interface MyModel extends Model {
  3.   readonly id: number;
  4. }
  6. // 需要声明静态模型,以便`findOne`等使用正确的类型.
  7. type MyModelStatic = typeof Model & {
  8.   new (values?: object, options?: BuildOptions): MyModel;
  9. }
  11. // TS无法从 `.define` 调用中获取正确的类定义,因此我们需要在此处进行转换.
  12. const MyDefineModel = <MyModelStatic>sequelize.define('MyDefineModel', {
  13.   id: {
  14.     primaryKey: true,
  15.     type: DataTypes.INTEGER.UNSIGNED,
  16.   }
  17. });
  19. function stuffTwo() {
  20.   MyDefineModel.findByPk(1, {
  21.     rejectOnEmpty: true,
  22.   })
  23.   .then(myModel => {
  24.     console.log(myModel.id);
  25.   });
  26. }