Typecript yöntemiyle Mongoose…?

Typescript'te Mongoose modeli uygulamaya çalışılıyor. Google'ın araştırılması yalnızca karma bir yaklaşımı ortaya çıkardı (JS ve TS'yi birleştirerek). JS olmadan oldukça saf yaklaşımımla User sınıfını uygulamaya nasıl başlayabilirim?

Bagaj olmadan IUserModel yapabilmek ister.

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

İşte bunu nasıl yapıyorum:

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;

Tür tanımlarınızı ve veritabanı uygulamasını ayırmak istiyorsanız başka bir alternatif.

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

Buradan ilham alın: https://github.com/Appsilon/styleguide/wiki/mongoose-typescript-models

Necroposting için özür dilerim ama bu yine de birisi için ilginç olabilir. Typegoose'un modelleri tanımlamak için daha modern ve zarif bir yol sağladığını düşünüyorum

İşte belgelerden bir örnek:

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

Mevcut bir bağlantı senaryosu için aşağıdakileri kullanabilirsiniz (gerçek durumlarda daha olası ve belgelerde ortaya çıkmamış olabilir):

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

Deneyin ts-mongoose. Eşlemeyi yapmak için koşullu türleri kullanır.

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

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

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

Buradaki yanıtların çoğu, TypeScript sınıfı / arabirimindeki ve firavun faresi şemasındaki alanları tekrar eder. Tek bir doğruluk kaynağına sahip olmamak, proje daha karmaşık hale geldikçe ve üzerinde daha fazla geliştirici çalıştıkça bir bakım riskini temsil eder: alanların senkronizasyondan çıkma olasılığı daha yüksektir . Bu özellikle, sınıf firavun faresi şemasına göre farklı bir dosyadayken kötüdür.

Alanları senkronize tutmak için, onları bir kez tanımlamak mantıklıdır. Bunu yapan birkaç kütüphane var:

• typeodm.io - tam test kapsamı, iyi örnekler, henüz çekiş yok
• mongoose-decorators-ts - en iyi İngilizce, henüz çekişme yok
• typegoose - en popüler, belgelerin iyileştirilmesi gerekiyor
• ts-mongoose - dekoratörleri kullanmaz, ikinci en popüler, aktif olarak bakımı yapılmaz
• mongoose-şema-dekoratörler - henüz çekişme yok
• mongoose- typcript - tip çatal

Henüz hiçbirinden tam olarak ikna olmadım, ancak typegoose aktif olarak korunuyor gibi görünüyor ve geliştirici PR'lerimi kabul etti.

Bir adım ileriyi düşünmek için: karışıma bir GraphQL şeması eklediğinizde, başka bir model çoğaltma katmanı görünür. Bu sorunun üstesinden gelmenin bir yolu , GraphQL şemasından TypeScript ve firavun faresi kodu oluşturmak olabilir .

İşte düz bir modeli firavun faresi şemasıyla eşleştirmenin güçlü bir yolu. Derleyici, mongoose.Schema'ya iletilen tanımların arayüzle eşleşmesini sağlayacaktır. Şemayı aldıktan sonra kullanabilirsiniz

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

Şemanızı aldıktan sonra, diğer yanıtlarda belirtilen yöntemleri kullanabilirsiniz.

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

Sadece başka bir yol ekleyin ( @types/mongooseile kurulmalıdır 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,
    // ...
}));

Ve arasındaki fark interfaceve typelütfen okuyunuz bu cevabı

Bu yolun bir avantajı vardır, Mongoose statik yöntem tiplerini ekleyebilirsiniz:

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

İşte Microsoft'taki adamlar bunu nasıl yapıyor. buraya

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

Node projenize TypeScript eklediğinizde bu mükemmel başlangıç ​​projesini kontrol etmenizi öneririm.

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

Bu vscode intellisenseikisinde de çalışır

• Kullanıcı Tipi User.findOne
• kullanıcı örneği u1._id

Kod:

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

Aşağıda, Mongoose dokümantasyonundan, TypeScript'e dönüştürülmüş loadClass () Kullanarak ES6 Sınıflarından Oluşturma örneğidir:

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

Statik findByFullNameyöntem için, tür bilgisini nasıl elde edeceğimi anlayamadım Person, bu yüzden onu <any>Personçağırmak istediğimde yayınlamak zorunda kaldım . Bunu nasıl düzelteceğinizi biliyorsanız, lütfen bir yorum ekleyin.

Bunun sahiptir plumier bir taraftar değilim firavunfaresi yardımcısı , ancak plumier kendisi olmadan kullanılan bağımsız olabilir . Typegoose'un aksine, Plumier'in özel yansıma kitaplığını kullanarak farklı bir yol izledi, bu da soğutmalı malzemeleri kullanmayı mümkün kıldı.

Özellikleri

1. Saf POJO (etki alanının herhangi bir sınıftan miras alması veya herhangi bir özel veri türü kullanması gerekmez), Model otomatik olarak oluşturulmuş, T & Documentbu nedenle belgeyle ilgili özelliklere erişmenin mümkün olduğu sonucuna varılmıştır .
2. Desteklenen TypeScript parametre özellikleri, strict:truetsconfig yapılandırmanız olduğunda iyidir . Ve parametre özellikleriyle, tüm özelliklerde dekoratör gerektirmez.
3. Typegoose gibi desteklenen alan özellikleri
4. Konfigürasyon firavun faresi ile aynıdır, böylece kolayca alışırsınız.
5. Programlamayı daha doğal hale getiren desteklenen kalıtım.
6. Model analizi, model adlarını ve uygun koleksiyon adını, uygulanan konfigürasyonu vb.

Kullanım

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

Mevcut Mongoose projeleri için bir çözüm arayanlar için:

Yakın zamanda bu sorunu çözmek için mongoose-tsgen'i geliştirdik (biraz geri bildirim almak isteriz!). Typegoose gibi mevcut çözümler tüm şemalarımızı yeniden yazmayı gerektirdi ve çeşitli uyumsuzluklar ortaya çıkardı. mongoose-tsgen , tüm Mongoose şemalarınız için Typescript arayüzlerini içeren bir index.d.ts dosyası oluşturan basit bir CLI aracıdır; çok az yapılandırma gerektirir veya hiç yapılandırma gerektirmez ve tüm Typescript projesiyle çok sorunsuz bir şekilde bütünleşir.

Şemanızın model türünü karşıladığından emin olmak istiyorsanız ve bunun tersi de geçerlidir, bu çözüm @bingles'in önerdiğinden daha iyi yazım sunar:

Yaygın dosya türü: ToSchema.ts(Panik yapmayın! Sadece kopyalayıp yapıştırın)

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

ve örnek bir model:

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

İşte @types/mongoosepaket için README'ye dayalı bir örnek .

Yukarıda zaten dahil edilen öğelerin yanı sıra, düzenli ve statik yöntemlerin nasıl dahil edileceğini gösterir:

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

Genel olarak bu BENİOKU, firavun faresi ile türlere yaklaşmak için harika bir kaynak gibi görünmektedir.

En son firavun faresi paketi typcript desteği ile geldi. Artık @ types / mongoose kullanmanıza gerek yok. Buradaki örneğime bakın.

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