猫鼬打字稿方式...？

Question

尝试在 Typescript 中实现 Mongoose 模型。搜了一下谷歌，只发现了一种混合方式（结合JS和TS）。如果没有 JS，如何以我相当幼稚的方法实现 User 类？

希望能够在没有包袱的情况下进行 IUserModel。

import {IUser} from './user.ts';
import {Document, Schema, Model} from 'mongoose';

// mixing in a couple of interfaces
interface IUserDocument extends IUser,  Document {}

// mongoose, why oh why '[String]' 
// TODO: investigate out why mongoose needs its own data types
let userSchema: Schema = new Schema({
  userName  : String,
  password  : String,
  firstName : String,
  lastName  : String,
  email     : String,
  activated : Boolean,
  roles     : [String]
});

// interface we want to code to?
export interface IUserModel extends Model<IUserDocument> {/* any custom methods here */}

// stumped here
export class User {
  constructor() {}
}

Answer 1

Mongoose 在 v5.11.0 中引入了官方支持的 TypeScript 绑定。 https://mongoosejs.com/docs/typescript.html 描述了 Mongoose 推荐的在 TypeScript 中使用 Mongoose 的方法。

Answer 2

嗯，我发现下面的链接真的很有帮助，作者在没有使用任何库的情况下详细描述了每一步。

Typescript With MongoDB and Node/Express

这真的对我很有帮助，希望对那些在不安装任何额外插件的情况下寻找解决方案的人非常有帮助。

不过，如果您愿意，可以尝试TypeORM 和TypeGoose

但我更喜欢不安装任何库:-)。

Answer 3

官方文档不鼓励TS接口扩展Document。

这种方法有效，但我们建议您的文档界面不要扩展 Document。使用 extends Document 使得 Mongoose 难以推断查询过滤器、精简文档和其他情况中存在哪些属性。

TS 接口

export interface IPerson {
  firstName: string;
  lastName: string;
  fullName: string;
}

架构

    const personSchema = new Schema<IPerson>({
      //You get intellisense of properties so less error prone
      firstName:{type:String},
      lastName:{type:String}
    })

   personSchema.virtual('fullName').get(function(this:IPerson) {
    return this.firstName + " " this.lastName
   });

   export const User = model<IPerson>('person',personSchema)

Answer 4

对于为现有 Mongoose 项目寻找解决方案的任何人：

我们最近构建了mongoose-tsgen 来解决这个问题（希望得到一些反馈！）。像 typegoose 这样的现有解决方案需要重写我们的整个模式并引入了各种不兼容性。 mongoose-tsgen 是一个简单的 CLI 工具，它生成一个 index.d.ts 文件，其中包含所有 Mongoose 模式的 Typescript 接口；它几乎不需要任何配置，并且可以与任何 Typescript 项目非常顺利地集成。

Answer 5

根据 mongoose 文档，您必须手动定义 TS 类型。 mongoose

但是当使用以下包时，不再需要定义 ts 接口。 mongoose-auto-ts

换句话说，pacakge 会自动推断文档类型。

例子：

// Schema and model must be imported from mongoose-auto-ts.
//import { Schema, model, connect } from 'mongoose';
import { connect } from 'mongoose';
import { Schema, model} from 'mongoose-auto-ts';

// 1. Create an interface representing a document in MongoDB.
// You don't need to create this interface:
/*interface User {
  name: string;
  email: string;
  avatar?: string;
}*/

// 2. Create a Schema corresponding to the document interface.
//No need to inject TS interface anymore
const schema = new Schema/*<User>*/({...});

// 3. Create a Model.
//No need to inject TS interface anymore
const UserModel = model/*<User>*/('User', schema);
.
.
.

Answer 6

TypeORM 是一个更好的现代解决方案。它同时支持 JavaScript 和 TypeScript。

TypeORM 是一种 ORM，可以在 NodeJS、Browser、Cordova、PhoneGap、Ionic、React Native、NativeScript、Expo 和 Electron 平台上运行，并且可以与 TypeScript 和 JavaScript（ES5、ES6、ES7、ES8）一起使用。

它有很多features。

它的目标是始终支持最新的 JavaScript 功能并提供额外的功能来帮助您开发使用数据库的任何类型的应用程序 - 从具有几个表的小型应用程序到具有多个数据库的大型企业应用程序。

它支持大多数数据库，如mysql、mariadb、postgres、cockroachdb、sqlite、mssql、oracle 等以及mongodb。

TypeORM 支持 Active Record 和 Data Mapper 模式，不像 当前存在的所有其他 JavaScript ORM，这意味着您可以 编写高质量、松耦合、可扩展、可维护 应用最高效的方式。

因此无需为不同的数据库学习不同的 ORM 或框架。

Answer 7

不确定这是您要查找的内容 但是有一个包叫Typegoose

Answer 8

我发现以下方法最简单、最有效，因为它使用您定义的额外接口验证架构中的键，帮助您保持一切同步。

当您在模式上添加/更改模式验证器属性（如 maxlength、小写等）时，您还会获得惊人的打字稿自动完成建议。

双赢！

import { Document, model, Schema, SchemaDefinitionProperty } from "mongoose";

type TDocument<Fields> = Fields & Document;
type TSchema<Fields> = Record<keyof Fields, SchemaDefinitionProperty>;

type UserFields = {
  email: string;
  firstName?: string;
  roles?: string[];
};

const userSchema: TSchema<UserFields> = {
  email: { type: Schema.Types.String, required: true, index: true },
  firstName: { type: Schema.Types.String, maxlength: 30, trim: true },
  roles: [
    { type: Schema.Types.String, maxlength: 20, lowercase: true },
  ],
};

export const User = model<TDocument<UserFields>>(
  "User",
  new Schema(userSchema, { timestamps: true })
);

最好的部分！您可以为所有模型重用 TDocument 和 TSchema 类型。

Answer 9

最新的 mongoose 包带有 typescript 支持。您不再需要使用@types/mongoose。在此处查看我的示例。

https://jasonching2005.medium.com/complete-guide-for-using-typescript-in-mongoose-with-lean-function-e55adf1189dc

Answer 10

如果您想确保您的架构满足模型类型，反之亦然，此解决方案提供比@bingles 建议的更好的类型：

常用类型文件： ToSchema.ts（别慌！复制粘贴就好）

import { Document, Schema, SchemaType, SchemaTypeOpts } from 'mongoose';

type NonOptionalKeys<T> = { [k in keyof T]-?: undefined extends T[k] ? never : k }[keyof T];
type OptionalKeys<T> = Exclude<keyof T, NonOptionalKeys<T>>;
type NoDocument<T> = Exclude<T, keyof Document>;
type ForceNotRequired = Omit<SchemaTypeOpts<any>, 'required'> & { required?: false };
type ForceRequired = Omit<SchemaTypeOpts<any>, 'required'> & { required: SchemaTypeOpts<any>['required'] };

export type ToSchema<T> = Record<NoDocument<NonOptionalKeys<T>>, ForceRequired | Schema | SchemaType> &
   Record<NoDocument<OptionalKeys<T>>, ForceNotRequired | Schema | SchemaType>;

和一个示例模型：

import { Document, model, Schema } from 'mongoose';
import { ToSchema } from './ToSchema';

export interface IUser extends Document {
   name?: string;
   surname?: string;
   email: string;
   birthDate?: Date;
   lastLogin?: Date;
}

const userSchemaDefinition: ToSchema<IUser> = {
   surname: String,
   lastLogin: Date,
   role: String, // Error, 'role' does not exist
   name: { type: String, required: true, unique: true }, // Error, name is optional! remove 'required'
   email: String, // Error, property 'required' is missing
   // email: {type: String, required: true}, // correct ?
   // Error, 'birthDate' is not defined
};

const userSchema = new Schema(userSchemaDefinition);

export const User = model<IUser>('User', userSchema);

Answer 11

只需另加一种方式（@types/mongoose必须与npm install --save-dev @types/mongoose一起安装）

import { IUser } from './user.ts';
import * as mongoose from 'mongoose';

interface IUserModel extends IUser, mongoose.Document {}

const User = mongoose.model<IUserModel>('User', new mongoose.Schema({
    userName: String,
    password: String,
    // ...
}));

还有interface和type的区别，请看this answer

这种方式有一个优势，可以添加Mongoose静态方法类型：

interface IUserModel extends IUser, mongoose.Document {
  generateJwt: () => string
}

Answer 12

这里的大多数答案都重复 TypeScript 类/接口和猫鼬模式中的字段。没有单一的事实来源代表着维护风险，因为项目变得更加复杂并且有更多的开发人员致力于它：字段更有可能不同步。当类与猫鼬模式位于不同的文件中时，这尤其糟糕。

为了保持字段同步，定义一次是有意义的。有几个库可以做到这一点：

• typeodm.io - 完整的测试覆盖率，很好的例子，还没有吸引力
• mongoose-decorators-ts - 最好的英语，还没有吸引力
• typegoose - 最受欢迎的文档needs improvement
• ts-mongoose - 不使用装饰器，第二受欢迎，没有积极维护
• mongoose-schema-decorators - 还没有吸引力
• mongoose-typescript - typegoose 的分支

我还没有完全相信他们中的任何一个，但 typegoose 似乎得到了积极的维护，并且开发人员接受了我的 PR。

提前思考：当您将 GraphQL 模式添加到混合中时，会出现另一层模型复制。解决此问题的一种方法可能是从 GraphQL 架构中发送 generate TypeScript and mongoose code。

Answer 13

我是 Plumier 的粉丝，它有 mongoose helper，但它可以独立使用，无需 Plumier 本身。与 Typegoose 不同的是，它使用 Plumier 的专用反射库采取了不同的方式，这使得使用很酷的东西成为可能。

特点

1. 纯 POJO（域不需要继承任何类，也不需要使用任何特殊数据类型），模型创建自动推断为T & Document，因此可以访问文档相关属性。
2. 支持TypeScript参数属性，有strict:truetsconfig配置就好了。并且使用参数属性不需要对所有属性都使用装饰器。
3. 支持的字段属性，例如 Typegoose
4. 配置与 mongoose 相同，因此您将很容易熟悉它。
5. 支持继承，使编程更加自然。
6. 模型分析，显示模型名称及其相应的集合名称、应用的配置等。

用法

import model, {collection} from "@plumier/mongoose"


@collection({ timestamps: true, toJson: { virtuals: true } })
class Domain {
    constructor(
        public createdAt?: Date,
        public updatedAt?: Date,
        @collection.property({ default: false })
        public deleted?: boolean
    ) { }
}

@collection()
class User extends Domain {
    constructor(
        @collection.property({ unique: true })
        public email: string,
        public password: string,
        public firstName: string,
        public lastName: string,
        public dateOfBirth: string,
        public gender: string
    ) { super() }
}

// create mongoose model (can be called multiple time)
const UserModel = model(User)
const user = await UserModel.findById()

Answer 14

这是一个基于 @types/mongoose 包的自述文件的示例。

除了上面已经包含的元素之外，它还显示了如何包含常规和静态方法：

import { Document, model, Model, Schema } from "mongoose";

interface IUserDocument extends Document {
  name: string;
  method1: () => string;
}
interface IUserModel extends Model<IUserDocument> {
  static1: () => string;
}

var UserSchema = new Schema<IUserDocument & IUserModel>({
  name: String
});

UserSchema.methods.method1 = function() {
  return this.name;
};
UserSchema.statics.static1 = function() {
  return "";
};

var UserModel: IUserModel = model<IUserDocument, IUserModel>(
  "User",
  UserSchema
);
UserModel.static1(); // static methods are available

var user = new UserModel({ name: "Success" });
user.method1();

总的来说，这个 README 似乎是使用 mongoose 处理类型的绝佳资源。

Answer 15

以下是微软员工的做法。 here

import mongoose from "mongoose";

export type UserDocument = mongoose.Document & {
    email: string;
    password: string;
    passwordResetToken: string;
    passwordResetExpires: Date;
...
};

const userSchema = new mongoose.Schema({
    email: { type: String, unique: true },
    password: String,
    passwordResetToken: String,
    passwordResetExpires: Date,
...
}, { timestamps: true });

export const User = mongoose.model<UserDocument>("User", userSchema);

我建议您在将 TypeScript 添加到 Node 项目时检查这个出色的入门项目。

https://github.com/microsoft/TypeScript-Node-Starter

Answer 16

这是来自 Mongoose 文档的示例，Creating from ES6 Classes Using loadClass()，已转换为 TypeScript：

import { Document, Schema, Model, model } from 'mongoose';
import * as assert from 'assert';

const schema = new Schema<IPerson>({ firstName: String, lastName: String });

export interface IPerson extends Document {
  firstName: string;
  lastName: string;
  fullName: string;
}

class PersonClass extends Model {
  firstName!: string;
  lastName!: string;

  // `fullName` becomes a virtual
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }

  set fullName(v) {
    const firstSpace = v.indexOf(' ');
    this.firstName = v.split(' ')[0];
    this.lastName = firstSpace === -1 ? '' : v.substr(firstSpace + 1);
  }

  // `getFullName()` becomes a document method
  getFullName() {
    return `${this.firstName} ${this.lastName}`;
  }

  // `findByFullName()` becomes a static
  static findByFullName(name: string) {
    const firstSpace = name.indexOf(' ');
    const firstName = name.split(' ')[0];
    const lastName = firstSpace === -1 ? '' : name.substr(firstSpace + 1);
    return this.findOne({ firstName, lastName });
  }
}

schema.loadClass(PersonClass);
const Person = model<IPerson>('Person', schema);

(async () => {
  let doc = await Person.create({ firstName: 'Jon', lastName: 'Snow' });
  assert.equal(doc.fullName, 'Jon Snow');
  doc.fullName = 'Jon Stark';
  assert.equal(doc.firstName, 'Jon');
  assert.equal(doc.lastName, 'Stark');

  doc = (<any>Person).findByFullName('Jon Snow');
  assert.equal(doc.fullName, 'Jon Snow');
})();

对于静态的findByFullName方法，我不知道如何获取Person的类型信息，所以在我想调用它的时候我不得不强制转换<any>Person。如果您知道如何解决此问题，请添加评论。

Answer 17

有了这个 vscode intellisense 可以同时工作

• 用户类型 User.findOne
• 用户实例 u1._id

---

代码：

// imports
import { ObjectID } from 'mongodb'
import { Document, model, Schema, SchemaDefinition } from 'mongoose'

import { authSchema, IAuthSchema } from './userAuth'

// the model

export interface IUser {
  _id: ObjectID, // !WARNING: No default value in Schema
  auth: IAuthSchema
}

// IUser will act like it is a Schema, it is more common to use this
// For example you can use this type at passport.serialize
export type IUserSchema = IUser & SchemaDefinition
// IUser will act like it is a Document
export type IUserDocument = IUser & Document

export const userSchema = new Schema<IUserSchema>({
  auth: {
    required: true,
    type: authSchema,
  }
})

export default model<IUserDocument>('user', userSchema)

Answer 18

很抱歉发布了 necropost，但这对某些人来说仍然很有趣。 我认为Typegoose 提供了更现代、更优雅的模型定义方式

这是文档中的一个示例：

import { prop, Typegoose, ModelType, InstanceType } from 'typegoose';
import * as mongoose from 'mongoose';

mongoose.connect('mongodb://localhost:27017/test');

class User extends Typegoose {
    @prop()
    name?: string;
}

const UserModel = new User().getModelForClass(User);

// UserModel is a regular Mongoose Model with correct types
(async () => {
    const u = new UserModel({ name: 'JohnDoe' });
    await u.save();
    const user = await UserModel.findOne();

    // prints { _id: 59218f686409d670a97e53e0, name: 'JohnDoe', __v: 0 }
    console.log(user);
})();

对于现有的连接场景，您可以使用以下方式（在实际情况中可能更有可能并且在文档中未发现）：

import { prop, Typegoose, ModelType, InstanceType } from 'typegoose';
import * as mongoose from 'mongoose';

const conn = mongoose.createConnection('mongodb://localhost:27017/test');

class User extends Typegoose {
    @prop()
    name?: string;
}

// Notice that the collection name will be 'users':
const UserModel = new User().getModelForClass(User, {existingConnection: conn});

// UserModel is a regular Mongoose Model with correct types
(async () => {
    const u = new UserModel({ name: 'JohnDoe' });
    await u.save();
    const user = await UserModel.findOne();

    // prints { _id: 59218f686409d670a97e53e0, name: 'JohnDoe', __v: 0 }
    console.log(user);
})();

Answer 19

这是一种将普通模型与猫鼬模式匹配的强类型方法。编译器将确保传递给 mongoose.Schema 的定义与接口匹配。一旦你有了架构，你就可以使用

common.ts

export type IsRequired<T> =
  undefined extends T
  ? false
  : true;

export type FieldType<T> =
  T extends number ? typeof Number :
  T extends string ? typeof String :
  Object;

export type Field<T> = {
  type: FieldType<T>,
  required: IsRequired<T>,
  enum?: Array<T>
};

export type ModelDefinition<M> = {
  [P in keyof M]-?:
    M[P] extends Array<infer U> ? Array<Field<U>> :
    Field<M[P]>
};

user.ts

import * as mongoose from 'mongoose';
import { ModelDefinition } from "./common";

interface User {
  userName  : string,
  password  : string,
  firstName : string,
  lastName  : string,
  email     : string,
  activated : boolean,
  roles     : Array<string>
}

// The typings above expect the more verbose type definitions,
// but this has the benefit of being able to match required
// and optional fields with the corresponding definition.
// TBD: There may be a way to support both types.
const definition: ModelDefinition<User> = {
  userName  : { type: String, required: true },
  password  : { type: String, required: true },
  firstName : { type: String, required: true },
  lastName  : { type: String, required: true },
  email     : { type: String, required: true },
  activated : { type: Boolean, required: true },
  roles     : [ { type: String, required: true } ]
};

const schema = new mongoose.Schema(
  definition
);

拥有架构后，您可以使用其他答案中提到的方法，例如

const userModel = mongoose.model<User & mongoose.Document>('User', schema);

Answer 20

试试ts-mongoose。它使用条件类型进行映射。

import { createSchema, Type, typedModel } from 'ts-mongoose';

const UserSchema = createSchema({
  username: Type.string(),
  email: Type.string(),
});

const User = typedModel('User', UserSchema);

Answer 21

我是这样做的：

export interface IUser extends mongoose.Document {
  name: string; 
  somethingElse?: number; 
};

export const UserSchema = new mongoose.Schema({
  name: {type:String, required: true},
  somethingElse: Number,
});

const User = mongoose.model<IUser>('User', UserSchema);
export default User;

Answer 22

如果你想分离你的类型定义和数据库实现，另一种选择。

import {IUser} from './user.ts';
import * as mongoose from 'mongoose';

type UserType = IUser & mongoose.Document;
const User = mongoose.model<UserType>('User', new mongoose.Schema({
    userName  : String,
    password  : String,
    /* etc */
}));

灵感来自这里：https://github.com/Appsilon/styleguide/wiki/mongoose-typescript-models