Mongoose टाइपस्क्रिप्ट तरीका ...?

Question 1

टाइपस्क्रिप्ट में एक Mongoose मॉडल को लागू करने की कोशिश कर रहा है। Google ने केवल हाइब्रिड दृष्टिकोण (JS और TS को मिलाकर) का खुलासा किया है। जेएस के बिना, मेरे बजाय भोले दृष्टिकोण पर उपयोगकर्ता वर्ग को लागू करने के बारे में कैसे जाना जाएगा?

सामान के बिना 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() {}
}

Question 2

यहाँ है कि मैं यह कैसे करते हैं:

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;

Question 3

एक अन्य विकल्प यदि आप अपनी प्रकार की परिभाषा और डेटाबेस कार्यान्वयन को अलग करना चाहते हैं।

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

Question 4

नेक्रोपोस्टिंग के लिए क्षमा करें, लेकिन यह अभी भी किसी के लिए दिलचस्प हो सकता है। मुझे लगता है कि टाइपगोज़ मॉडल को परिभाषित करने के लिए अधिक आधुनिक और सुरुचिपूर्ण तरीका प्रदान करता है

यहाँ डॉक्स से एक उदाहरण है:

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

Question 5

कोशिश करो ts-mongoose। यह मानचित्रण करने के लिए सशर्त प्रकार का उपयोग करता है।

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

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

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

Question 6

यहां अधिकांश उत्तर टाइपस्क्रिप्ट क्लास / इंटरफ़ेस में फ़ील्ड्स और मैंगोज़ोज़ स्कीमा में दोहराते हैं। सत्य का एक भी स्रोत नहीं होना एक रखरखाव जोखिम का प्रतिनिधित्व करता है, क्योंकि परियोजना अधिक जटिल हो जाती है और अधिक डेवलपर्स इस पर काम करते हैं: फ़ील्ड सिंक से बाहर निकलने की अधिक संभावना है । यह विशेष रूप से बुरा है जब वर्ग एक अलग फ़ाइल बनाम मोंगोज़ स्कीमा में होता है।

खेतों को सिंक में रखने के लिए, उन्हें एक बार परिभाषित करने के लिए समझ में आता है। कुछ पुस्तकालय हैं जो ऐसा करते हैं:

typeodm.io - पूर्ण परीक्षण कवरेज, अच्छे उदाहरण, अभी तक कोई कर्षण नहीं है
नेवला-सज्जाकार-ts - सर्वश्रेष्ठ अंग्रेजी, अभी तक कोई कर्षण नहीं है
typegoose - सबसे लोकप्रिय, प्रलेखन सुधार की आवश्यकता है
ts-mongoose - डेकोरेटर्स का उपयोग नहीं करता है, दूसरा सबसे लोकप्रिय, सक्रिय रूप से बनाए नहीं रखा गया है
नेवला-स्कीमा-सज्जाकार - अभी तक कोई कर्षण नहीं है
नेवला-टाइपप्रति - typegoose का कांटा

मैं अभी तक उनमें से किसी के द्वारा पूरी तरह से आश्वस्त नहीं हुआ हूं, लेकिन टाइपोगो सक्रिय रूप से बनाए रखा लगता है, और डेवलपर ने मेरे पीआर को स्वीकार कर लिया है।

एक कदम आगे की सोचने के लिए: जब आप मिश्रण में एक ग्राफ्केल स्कीमा जोड़ते हैं, तो मॉडल दोहराव की एक और परत दिखाई देती है। इस समस्या को दूर करने का एक तरीका ग्राफकल्क स्कीमा से टाइपस्क्रिप्ट और मोंगोज़ो कोड उत्पन्न करना हो सकता है ।

Question 7

यहां एक सामान्य मॉडल के साथ एक सामान्य मॉडल से मेल खाने का एक मजबूत टाइप किया गया तरीका है। संकलक इंटरफ़ेस के साथ मेल खाता है। स्कीमा होने के बाद, आप उपयोग कर सकते हैं

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

Question 8

बस दूसरा तरीका जोड़ें (के @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, कृपया इसे पढ़ें क्या यह उत्तर

इस तरह से एक फायदा है, आप मानगो स्थैतिक विधि टाइपिंग जोड़ सकते हैं:

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

Question 9

यहाँ है कि 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);

जब आप अपने नोड प्रोजेक्ट में टाइपस्क्रिप्ट जोड़ते हैं, तो मैं इस उत्कृष्ट स्टार्टर प्रोजेक्ट को देखने की सलाह देता हूं।

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

Question 10

इसके साथ `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)

Question 11

लोडिंगक्लास () का उपयोग करके ES6 क्लासेस से बना Mongoose डॉक्यूमेंटेशन का उदाहरण यहां टाइपस्क्रिप्ट में दिया गया है:

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जब मुझे इसे कॉल करना होता है तो मुझे कास्ट करना पड़ता है। यदि आप जानते हैं कि कैसे ठीक करें तो कृपया एक टिप्पणी जोड़ें।

Question 12

मैं प्लमियर का प्रशंसक हूं, इसमें मैंगोज हेल्पर है , लेकिन इसका उपयोग प्लूमियर के बिना ही किया जा सकता है । Typegoose के विपरीत, Plumier की समर्पित परावर्तन लाइब्रेरी का उपयोग करके इसका अलग रास्ता लिया गया, जिससे कि कूल सामान का उपयोग करना संभव हो सके।

विशेषताएं

शुद्ध POJO (डोमेन को किसी भी वर्ग से प्राप्त करने की आवश्यकता नहीं है, और न ही किसी विशेष डेटा प्रकार का उपयोग करके), मॉडल का निर्माण स्वचालित रूप से अनुमान लगाया गया है T & Document इस प्रकार दस्तावेज़ से संबंधित गुणों तक पहुंच संभव है।
टाइपस्क्रिप्ट पैरामीटर गुण का समर्थन किया, जब आपके पास यह अच्छा है strict:true tsconfig कॉन्फ़िगरेशन है। और पैरामीटर गुणों के साथ सभी गुणों पर डेकोरेटर की आवश्यकता नहीं होती है।
समर्थित फ़ील्ड गुण जैसे Typegoose
कॉन्फ़िगरेशन मोंगोज़ के समान है, जिससे आप आसानी से परिचित हो जाएंगे।
समर्थित विरासत जो प्रोग्रामिंग को और अधिक प्राकृतिक बनाती है।
मॉडल विश्लेषण, मॉडल के नाम और उसका उपयुक्त संग्रह नाम, विन्यास लागू आदि दिखाना।

प्रयोग

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

Question 13

मौजूदा Mongoose परियोजनाओं के लिए एक समाधान की तलाश में किसी के लिए:

हमने हाल ही में इस मुद्दे को संबोधित करने के लिए मोंगोसे-टीएसजीएन बनाया था (कुछ प्रतिक्रिया पसंद आएगी!)। मौजूदा प्रकार जैसे मौजूदा समाधानों ने हमारे पूरे स्कीमा को फिर से लिखना और विभिन्न असंगतताओं को पेश किया। mongoose-tsgen एक सरल सीएलआई उपकरण है जो एक index.d.ts फ़ाइल बनाता है जिसमें आपके सभी Mongoose स्कीमा के लिए टाइपस्क्रिप्ट इंटरफ़ेस होता है; इसके लिए किसी भी कॉन्फ़िगरेशन की आवश्यकता नहीं है और किसी भी टाइपस्क्रिप्ट प्रोजेक्ट के साथ बहुत आसानी से एकीकृत होता है।

Question 14

यदि आप यह सुनिश्चित करना चाहते हैं कि आपका स्कीमा मॉडल प्रकार को संतुष्ट करता है और इसके विपरीत, तो यह समाधान उस प्रकार से बेहतर टाइपिंग प्रदान करता है, जो @ सुझाव ने दिया था:

सामान्य प्रकार की फ़ाइल: 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);

Question 15

यहाँ एक उदाहरण के लिए 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 मानस के साथ संपर्क करने के लिए एक शानदार संसाधन प्रतीत होता है।

Question 16

नवीनतम मानगो पैकेज टाइपस्क्रिप्ट समर्थन के साथ आया है। अब आपको @ प्रकार / मोंगोज़ का उपयोग करने की आवश्यकता नहीं है। मेरा उदाहरण यहाँ देखें।

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

Mongoose टाइपस्क्रिप्ट तरीका ...?

इसके साथ vscode intellisenseदोनों पर काम करता है

कोड:

विशेषताएं

प्रयोग

इसके साथ `vscode intellisense`दोनों पर काम करता है