javascript - traductor - typescript official documentation

¿Mongoose la manera de Typescript...?

Question

Intentando implementar un modelo Mongoose en Typescript. Scouring the Google ha revelado solo un enfoque híbrido (que combina JS y TS). ¿Cómo se podría implementar la clase User, en mi enfoque más bien ingenuo, sin JS?

Quiere poder IUserModel sin el equipaje.

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

Así es como lo hago:

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 2

Lo siento por necroposting, pero esto puede ser interesante para alguien. Creo que Typegoose proporciona una manera más moderna y elegante de definir modelos

Aquí hay un ejemplo de los documentos:

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);
})();

Answer 3

Otra alternativa si desea separar las definiciones de tipo y la implementación de la base de datos.

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 */
}));

Inspiración desde aquí: https://github.com/Appsilon/styleguide/wiki/mongoose-typescript-models

Answer 4

Si ha instalado @types/mongoose

npm install --save-dev @types/mongoose

Puedes hacerlo

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

PD: copiada la respuesta de @Hongbo Miao

Answer 5

Solo agrega otra forma:

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,
// ...
}));

Y la diferencia entre interface y type , lea esta respuesta

De esta manera tiene una ventaja, puede agregar tipizaciones de métodos estáticos de Mongoose:

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