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
}