Мангустувати машинописним способом ...?

Спроба реалізувати модель Mongoose у Typescript. Дослідження Google виявило лише гібридний підхід (поєднання JS та TS). Як можна було б застосувати клас User, на мій досить наївний підхід, без JS?

Хочете мати можливість користуватися 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() {}
}

Ось як я це роблю:

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;

Ще одна альтернатива, якщо ви хочете відключити визначення типів та реалізацію бази даних.

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

Вибачте за некропостінг, але це все одно може бути цікавим для когось. Я думаю, 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);
})();

Спробуйте ts-mongoose. Він використовує умовні типи для здійснення зіставлення.

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

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

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

Більшість відповідей тут повторюють поля класу / інтерфейсу TypeScript та схеми мангуста. Відсутність єдиного джерела істини представляє ризик для обслуговування, оскільки проект ускладнюється, і більше розробників працює над ним: поля, швидше за все, виходять з синхронізації . Це особливо погано, коли клас знаходиться в іншому файлі порівняно зі схемою мангуста.

Щоб синхронізувати поля, має сенс визначити їх один раз. Є кілька бібліотек, які роблять це:

• typeodm.io - повне охоплення тестом, хороші приклади, ще немає тяги
• mongoose-decorators-ts - найкраща англійська, ще немає тяги
• typegoose - найпопулярніша, документація потребує вдосконалення
• ts-мангуст - не використовує декоратори, другий за популярністю, не підтримується активно
• mongoose-schema-decorators - тяги поки що немає
• mongoose- typecript - виделка typegoose

Я ще не до кінця переконаний будь-яким із них, але typegoose, здається, активно підтримується, і розробник прийняв мої PR.

Щоб подумати на крок вперед: коли ви додаєте схему GraphQL в мікс, з’являється інший шар дублювання моделі. Одним із способів подолання цієї проблеми може бути створення TypeScript та мангустського коду зі схеми GraphQL.

Ось сильний набраний спосіб порівняння простої моделі зі схемою мангуста. Компілятор забезпечить, щоб визначення, передані mongoose.Schema, відповідали інтерфейсу. Отримавши схему, ви можете використовувати її

загальний.ц

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

Просто додайте інший спосіб ( @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, будь ласка, прочитайте цю відповідь

Цей спосіб має перевагу, ви можете додати статичні типи тиску методу Mongoose:

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

Ось як це роблять хлопці з Microsoft. тут

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

З цим 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)

Ось приклад з документації Mongoose, створення з класів ES6 за допомогою 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коли я хочу його викликати. Якщо ви знаєте, як це виправити, додайте коментар.

Я шанувальник Plumier, він має мангуста-помічника , але його можна використовувати окремо без самого Plumier . На відміну від Typegoose, він пішов іншим шляхом, використовуючи виділену бібліотеку відображень Plumier, яка дозволяє використовувати охолоджувальні матеріали.

Особливості

1. Чистий POJO (домен не потрібно успадковувати від будь-якого класу, а також не використовувати будь-який спеціальний тип даних), Модель створена автоматично, оскільки T & Documentтаким чином можна отримати доступ до властивостей документа.
2. Підтримувані властивості параметрів TypeScript, це добре, коли у вас є strict:trueконфігурація tsconfig. А з властивостями параметрів не потрібно декоратор для всіх властивостей.
3. Підтримувані властивості поля, такі як Typegoose
4. Конфігурація така ж, як і у мангуста, тому ви з нею легко ознайомитесь.
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()

Для тих, хто шукає рішення для існуючих проектів Mongoose:

Нещодавно ми створили mongoose-tsgen для вирішення цієї проблеми (хотілося б отримати відгук!). Існуючі рішення, такі як typegoose, вимагали переписувати всі наші схеми та вводити різні несумісності. mongoose-tsgen - це простий інструмент CLI, який генерує файл index.d.ts, що містить інтерфейси Typescript для всіх ваших схем Mongoose; він не вимагає ніякої конфігурації і дуже гладко інтегрується з будь-яким проектом Typescript.

Ось приклад, заснований на README для @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 видається фантастичним ресурсом для наближення типів з мангустом.

Якщо ви хочете переконатися, що ваша схема відповідає типу моделі, і навпаки, це рішення пропонує кращий набір тексту, ніж те, що пропонував @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);