TypeScript

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

由于 Sequelize 严重依赖于运行时属性分配,因此 TypeScript 在开箱即用时不会很有用. 为了使模型可用,需要大量的手动类型声明.

安装

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

  • @types/node (在 node 项目中这是通常是必须的)
  • @types/validator

使用

带有严格类型检查的最小 TypeScript 项目示例.

  1. import {
  2.   Sequelize,
  3.   Model,
  4.   DataTypes,
  5.   HasManyGetAssociationsMixin,
  6.   HasManyAddAssociationMixin,
  7.   HasManyHasAssociationMixin,
  8.   Association,
  9.   HasManyCountAssociationsMixin,
  10.   HasManyCreateAssociationMixin,
  11.   Optional,
  12. } from 'sequelize';
  14. const sequelize = new Sequelize('mysql://root:asd123@localhost:3306/mydb');
  16. // These are all the attributes in the User model
  17. interface UserAttributes {
  18.   id: number;
  19.   name: string;
  20.   preferredName: string | null;
  21. }
  23. // Some attributes are optional in `User.build` and `User.create` calls
  24. interface UserCreationAttributes extends Optional<UserAttributes, 'id'> {}
  26. class User extends Model<UserAttributes, UserCreationAttributes>
  27.   implements UserAttributes {
  28.   public id!: number; // Note that the `null assertion` `!` is required in strict mode.
  29.   public name!: string;
  30.   public preferredName!: string | null; // for nullable fields
  32.   // timestamps!
  33.   public readonly createdAt!: Date;
  34.   public readonly updatedAt!: Date;
  36.   // Since TS cannot determine model association at compile time
  37.   // we have to declare them here purely virtually
  38.   // these will not exist until `Model.init` was called.
  39.   public getProjects!: HasManyGetAssociationsMixin<Project>; // Note the null assertions!
  40.   public addProject!: HasManyAddAssociationMixin<Project, number>;
  41.   public hasProject!: HasManyHasAssociationMixin<Project, number>;
  42.   public countProjects!: HasManyCountAssociationsMixin;
  43.   public createProject!: HasManyCreateAssociationMixin<Project>;
  45.   // You can also pre-declare possible inclusions, these will only be populated if you
  46.   // actively include a relation.
  47.   public readonly projects?: Project[]; // Note this is optional since it's only populated when explicitly requested in code
  49.   public static associations: {
  50.     projects: Association<User, Project>;
  51.   };
  52. }
  54. interface ProjectAttributes {
  55.   id: number;
  56.   ownerId: number;
  57.   name: string;
  58. }
  60. interface ProjectCreationAttributes extends Optional<ProjectAttributes, 'id'> {}
  62. class Project extends Model<ProjectAttributes, ProjectCreationAttributes>
  63.   implements ProjectAttributes {
  64.   public id!: number;
  65.   public ownerId!: number;
  66.   public name!: string;
  68.   public readonly createdAt!: Date;
  69.   public readonly updatedAt!: Date;
  70. }
  72. interface AddressAttributes {
  73.   userId: number;
  74.   address: string;
  75. }
  77. // You can write `extends Model<AddressAttributes, AddressAttributes>` instead,
  78. // but that will do the exact same thing as below
  79. class Address extends Model<AddressAttributes> implements AddressAttributes {
  80.   public userId!: number;
  81.   public address!: string;
  83.   public readonly createdAt!: Date;
  84.   public readonly updatedAt!: Date;
  85. }
  87. Project.init(
  88.   {
  89.     id: {
  90.       type: DataTypes.INTEGER.UNSIGNED,
  91.       autoIncrement: true,
  92.       primaryKey: true,
  93.     },
  94.     ownerId: {
  95.       type: DataTypes.INTEGER.UNSIGNED,
  96.       allowNull: false,
  97.     },
  98.     name: {
  99.       type: new DataTypes.STRING(128),
  100.       allowNull: false,
  101.     },
  102.   },
  103.   {
  104.     sequelize,
  105.     tableName: 'projects',
  106.   },
  107. );
  109. User.init(
  110.   {
  111.     id: {
  112.       type: DataTypes.INTEGER.UNSIGNED,
  113.       autoIncrement: true,
  114.       primaryKey: true,
  115.     },
  116.     name: {
  117.       type: new DataTypes.STRING(128),
  118.       allowNull: false,
  119.     },
  120.     preferredName: {
  121.       type: new DataTypes.STRING(128),
  122.       allowNull: true,
  123.     },
  124.   },
  125.   {
  126.     tableName: 'users',
  127.     sequelize, // passing the `sequelize` instance is required
  128.   },
  129. );
  131. Address.init(
  132.   {
  133.     userId: {
  134.       type: DataTypes.INTEGER.UNSIGNED,
  135.     },
  136.     address: {
  137.       type: new DataTypes.STRING(128),
  138.       allowNull: false,
  139.     },
  140.   },
  141.   {
  142.     tableName: 'address',
  143.     sequelize, // passing the `sequelize` instance is required
  144.   },
  145. );
  147. // Here we associate which actually populates out pre-declared `association` static and other methods.
  148. User.hasMany(Project, {
  149.   sourceKey: 'id',
  150.   foreignKey: 'ownerId',
  151.   as: 'projects', // this determines the name in `associations`!
  152. });
  154. Address.belongsTo(User, { targetKey: 'id' });
  155. User.hasOne(Address, { sourceKey: 'id' });
  157. async function doStuffWithUser() {
  158.   const newUser = await User.create({
  159.     name: 'Johnny',
  160.     preferredName: 'John',
  161.   });
  162.   console.log(newUser.id, newUser.name, newUser.preferredName);
  164.   const project = await newUser.createProject({
  165.     name: 'first!',
  166.   });
  168.   const ourUser = await User.findByPk(1, {
  169.     include: [User.associations.projects],
  170.     rejectOnEmpty: true, // Specifying true here removes `null` from the return type!
  171.   });
  173.   // Note the `!` null assertion since TS can't know if we included
  174.   // the model or not
  175.   console.log(ourUser.projects![0].name);
  176. }

使用非严格类型

Sequelize v5 的类型允许你定义模型而无需指定属性类型. 对于向后兼容以及在你觉得对属性进行严格检查是不值得的情况下, 这仍然是可行的.

  1. import { Sequelize, Model, DataTypes } from 'sequelize';
  3. const sequelize = new Sequelize('mysql://root:asd123@localhost:3306/mydb');
  5. class User extends Model {
  6.   public id!: number; // Note that the `null assertion` `!` is required in strict mode.
  7.   public name!: string;
  8.   public preferredName!: string | null; // for nullable fields
  9. }
  11. User.init(
  12.   {
  13.     id: {
  14.       type: DataTypes.INTEGER.UNSIGNED,
  15.       autoIncrement: true,
  16.       primaryKey: true,
  17.     },
  18.     name: {
  19.       type: new DataTypes.STRING(128),
  20.       allowNull: false,
  21.     },
  22.     preferredName: {
  23.       type: new DataTypes.STRING(128),
  24.       allowNull: true,
  25.     },
  26.   },
  27.   {
  28.     tableName: 'users',
  29.     sequelize, // passing the `sequelize` instance is required
  30.   },
  31. );
  33. async function doStuffWithUserModel() {
  34.   const newUser = await User.create({
  35.     name: 'Johnny',
  36.     preferredName: 'John',
  37.   });
  38.   console.log(newUser.id, newUser.name, newUser.preferredName);
  40.   const foundUser = await User.findOne({ where: { name: 'Johnny' } });
  41.   if (foundUser === null) return;
  42.   console.log(foundUser.name);
  43. }

使用 sequelize.define

在 v5 之前的 Sequelize 版本中, 定义模型的默认方式涉及使用 sequelize.define. 仍然可以使用它来定义模型, 也可以使用接口在这些模型中添加类型.

  1. import { Sequelize, Model, DataTypes, Optional } from 'sequelize';
  3. const sequelize = new Sequelize('mysql://root:asd123@localhost:3306/mydb');
  5. // We recommend you declare an interface for the attributes, for stricter typechecking
  6. interface UserAttributes {
  7.   id: number;
  8.   name: string;
  9. }
  11. // Some fields are optional when calling UserModel.create() or UserModel.build()
  12. interface UserCreationAttributes extends Optional<UserAttributes, 'id'> {}
  14. // We need to declare an interface for our model that is basically what our class would be
  15. interface UserInstance
  16.   extends Model<UserAttributes, UserCreationAttributes>,
  17.     UserAttributes {}
  19. const UserModel = sequelize.define<UserInstance>('User', {
  20.   id: {
  21.     primaryKey: true,
  22.     type: DataTypes.INTEGER.UNSIGNED,
  23.   },
  24.   name: {
  25.     type: DataTypes.STRING,
  26.   }
  27. });
  29. async function doStuff() {
  30.   const instance = await UserModel.findByPk(1, {
  31.     rejectOnEmpty: true,
  32.   });
  33.   console.log(instance.id);
  34. }

如果你对模型上非严格的属性检查命令感到满意，则可以通过定义 Instance 来扩展 Model 而无需泛型类型中的任何属性, 从而节省一些代码.

  1. import { Sequelize, Model, DataTypes } from 'sequelize';
  3. const sequelize = new Sequelize('mysql://root:asd123@localhost:3306/mydb');
  5. // We need to declare an interface for our model that is basically what our class would be
  6. interface UserInstance extends Model {
  7.   id: number;
  8.   name: string;
  9. }
  11. const UserModel = sequelize.define<UserInstance>('User', {
  12.   id: {
  13.     primaryKey: true,
  14.     type: DataTypes.INTEGER.UNSIGNED,
  15.   },
  16.   name: {
  17.     type: DataTypes.STRING,
  18.   },
  19. });
  21. async function doStuff() {
  22.   const instance = await UserModel.findByPk(1, {
  23.     rejectOnEmpty: true,
  24.   });
  25.   console.log(instance.id);
  26. }