Mongoose: Avertissement d'obsolescence

Créé le 1 juil. 2016  ·  79Commentaires  ·  Source: Automattic/mongoose

Je reçois cet avertissement

(node:3341) DeprecationWarning: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead: http://mongoosejs.com/docs/promises.html

après je fais

driver.createCar({
          carName: 'jeep',
          availableSeats: 4,
        }, callback);

le pilote est une instance de la classe Driver

const carSchema = new Schema({
  carName: String,
  availableSeats: Number,
  createdOn: { type: Date, default: Date.now },
});
const driverSchema = new Schema({
  email: String,
  name: String,
  city: String,
  phoneNumber: String,
  cars: [carSchema],
  userId: {
    type: Schema.Types.ObjectId,
    required: true,
  },
  createdOn: { type: Date, default: Date.now },
});
const DriverModel = mongoose.model('Driver', driverSchema);

class Driver extends DriverModel {
  getCurrentDate() {
    return moment().format();
  }
  create(cb) {
    // save driver
    this.createdOn = this.getCurrentDate();
    this.save(cb);
  }
  remove(cb) {
    super.remove({
      _id: this._id,
    }, cb);
  }
  createCar(carData, cb) {
    this.cars.push(carData);
    this.save(cb);
  }
  getCars() {
    return this.cars;
  }
}

des pensées sur ce que je fais mal?

help

Commentaire le plus utile

J'ai résolu cet avertissement en faisant

mongoose.Promise = global.Promise;

Juste avant d'appeler mongoose.connect

// connect to mongo function
core.connect = function connect(opts) {
  mongoose.Promise = global.Promise;
  mongoose.connect(`mongodb://${opts.server}:${opts.port}/${opts.db}`);
  return mongoose.connection;
};

Tous les 79 commentaires

Hmm utilisez-vous des promesses n'importe où? Vous ne devriez pas recevoir cet avertissement à moins que vous n'utilisiez des promesses...

non je n'utilise pas de promesses

Je viens de commencer à avoir ce problème aussi. Ne pas utiliser les promesses que je connais !

J'ai résolu cet avertissement en faisant

mongoose.Promise = global.Promise;

Juste avant d'appeler mongoose.connect

// connect to mongo function
core.connect = function connect(opts) {
  mongoose.Promise = global.Promise;
  mongoose.connect(`mongodb://${opts.server}:${opts.port}/${opts.db}`);
  return mongoose.connection;
};

Oui, cet avertissement est censé vous dire de changer la bibliothèque de promesses par défaut des mangoustes si vous utilisez des promesses, mais cela ne devrait pas arriver à moins que vous n'appeliez .then quelque part

Je l'obtiens mais je l'obtiens seulement là où j'enregistre un objet puis le modifie dans le rappel et enregistre à nouveau

J'ai essayé l'approche @SAudeLOG pour attribuer une promesse à la mangouste avant la connexion de la mangouste mais je reçois toujours cette erreur

J'utilise les fonctions asynchrones es7 et mon code est bloqué lorsque j'essaie de Model.findOne({})

La solution fournie par @SAudeLOG fonctionne. Comme @IrishAdo , je ne reçois cela que lors de la sauvegarde d'un objet également. C'est peut-être à cause de l'un des plugins de mangouste que j'utilise avec la bibliothèque de promesses Bluebird.

Voici une liste des dépendances que j'utilise

  "dependencies": {
    "async": "^2.0.0-rc.6",
    "body-parser": "^1.15.0",
    "bower": "^1.7.7",
    "compression": "^1.6.1",
    "connect-mongo": "^1.2.1",
    "consolidate": "^0.14.1",
    "cookie-parser": "^1.4.3",
    "express": "^4.13.4",
    "express-jwt": "^3.4.0",
    "express-session": "^1.13.0",
    "express-validator": "^2.20.8",
    "faker": "^3.1.0",
    "http-errors": "^1.5.0",
    "jsonwebtoken": "^7.0.1",
    "lodash": "^4.13.1",
    "method-override": "^2.3.5",
    "mongoose": "^4.4.3",
    "mongoose-beautiful-unique-validation": "^3.0.0",
    "mongoose-delete": "^0.3.3",
    "mongoose-validator": "^1.2.5",
    "morgan": "^1.6.1",
    "passport": "^0.3.2",
    "passport-local": "^1.0.0",
    "swig": "^1.4.2"
  }

Je n'utilise pas de plugins ni de promesses et je reçois également cet avertissement (sur [email protected]).

Exécutant mon application avec "--trace-deprecation", j'ai :

Trace: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead:
http://mongoosejs.com/docs/promises.html
    at Object.exports._printDeprecationMessage (internal/util.js:30:13)
    at Promise.deprecated [as then] (internal/util.js:54:22)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:188:11)
    at EmbeddedDocument.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:219:11)
    at _next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:186:18)
    at EmbeddedDocument.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:173:18)
    at EmbeddedDocument._next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at EmbeddedDocument.proto.(anonymous function) [as $__original_save] (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:108:20)
    at .\node_modules\mongoose\lib\document.js:1917:24
    at new Promise.ES6 (.\node_modules\mongoose\lib\promise.js:45:3)
    at EmbeddedDocument.wrappedPointCut [as save] (.\node_modules\mongoose\lib\document.js:1893:14)
    at async.each.i (.\node_modules\mongoose\lib\schema.js:225:18)
    at .\node_modules\async\lib\async.js:181:20
    at Object.async.forEachOf.async.eachOf (.\node_modules\async\lib\async.js:233:13)
    at Object.async.forEach.async.each (.\node_modules\async\lib\async.js:209:22)
    at model.Object.defineProperty.value.fn (.\node_modules\mongoose\lib\schema.js:223:15)
    at _next (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:62:30)
    at fnWrapper (.\node_modules\mongoose\node_modules\hooks-fixed\hooks.js:186:18)
    at .\node_modules\mongoose\lib\schema.js:200:17
    at .\node_modules\mongoose\node_modules\kareem\index.js:127:16
    at nextTickCallbackWith0Args (node.js:420:9)
    at process._tickDomainCallback (node.js:390:13)

J'ai le même problème, si cela peut vous aider, il est spécifiquement déclenché lorsque j'essaie de créer des documents contenant un tableau de sous-documents, quelque chose comme:

var data = {
  field: 'value',
  another_field: [{subdocfield1: 'value', subdocfield2: 'value'}]
} 

mySchema.create(data, cb)

Cela ne se produit pas avec d'autres collections qui n'ont pas de sous-documents, cela ne se produit même pas si j'émets l'instruction create sans les données de sous-doc, comme ceci :

var data = {
  field: 'value'
} 

mySchema.create(data, cb)

_Remarque :_ mongoose.Promise = global.Promise a résolu le problème d'avertissement pour moi

Même avertissement de dépréciation lorsque j'utilise remove() sur un document. Je n'utilise pas de promesses ici ou ailleurs dans mon code.

Je viens d'avoir cette erreur lors de l'utilisation Model.create(objects, callback); , peut-être que ce correctif n'a pas encore été publié sur npm ?

Obtenir ceci, heureux de le lire n'est pas alarmant. Je vais regarder de plus près cela pour aider au débogage quand cela se produit.

J'obtiens cela aussi, et je n'utilise nulle part les promesses de mangouste.

J'ai pu le retracer jusqu'à un appel model.save à l'intérieur d'un rappel de la bibliothèque on-headers , et le modèle a été créé en dehors du rappel, avant qu'il ne soit appelé, au cas où cela aiderait quelqu'un. Placer à la fois la création de modèle et l'appel de sauvegarde dans le rappel ne fait aucune différence.

Face à ce problème sur le nœud v4.4.6 alors que sur la v4.4.2 cela semble fonctionner

Exemple de code @SKatiyar s'il vous plaît

pareil avec moi, recevoir ce message après avoir appelé la méthode save(), assez pour que je m'en soucie

Cela marche! Avant mongoose.connect(MONGO_URI); ajouter mongoose.Promise = global.Promise;

Le code suivant suffit à reproduire de mon côté :

const mongoose = require('mongoose');
const schema = new mongoose.Schema({
  data: { type: Number }
});
const Model = mongoose.model('schema', schema);
mongoose.connect('mongodb://127.0.0.1:27017/somedatabase');
const newModel = new Model({ data: 1 });
const save = newModel.save(() => {
  console.log('saved model');
});
console.log(typeof save.then); //=> 'function'

La chose étrange que je peux voir ici est que l'utilisation newModel.save(callback) renvoie toujours une promesse (ou je suppose que c'est une promesse, puisque le type de .then est 'function' ). Est-ce un comportement attendu ?

Voici mes versions :
Nœud : v6.3.1
Mangouste : v4.5.8

Faites-moi savoir si vous avez besoin d'autres informations de ma part.

@dvlsg oui c'est le comportement attendu actuellement, save renverra toujours une promesse même si vous passez un rappel

Eh bien, je suppose que cela expliquerait au moins pourquoi les gens voient l'avertissement de promesse même lorsqu'ils ne pensent pas qu'ils utilisent des promesses.

Cela explique tout .. Je suis juste un peu paranoïaque et je voulais me débarrasser de tous les avertissements 💃

C'est de ma faute, yup .save() renvoie une promesse donc c'est prévu, mais quand même, l'avertissement m'a fait me demander. http://mongoosejs.com/docs/promises.html (je devais juste lire le premier paragraphe 🎱)

Donc .save() renvoie une promesse mais vous ne devriez pas recevoir cet avertissement sauf si vous appelez .then() . Si vous obtenez cet avertissement sans appeler .then() dans votre code, cela signifie que la mangouste utilise une promesse quelque part où elle ne devrait pas, veuillez donc ouvrir un problème séparé avec des exemples de code :+1 :

À mon humble avis, ce message devrait être une erreur ("les choses ne fonctionnent pas") plutôt qu'un avertissement ("faites attention mais cela devrait fonctionner"), car il est en fait renvoyé comme erreur dans le rappel.

J'ai rencontré ce problème et la méthode aModel.save() n'a pas fonctionné pour être insérée dans MongoDB. Il a fallu un certain temps pour trouver la cause de ce problème. Après avoir appliqué "mongoose.Promise = global.Promise;", cela a réussi.

J'utilisais "mongoose": "^4.5.9".

Save devrait fonctionner correctement avec la bibliothèque de promesses par défaut, pouvez-vous fournir un exemple de code ?

@vkarpov15

Vous avez raison. J'ai juste essayé et échoué à recréer à partir de zéro le résultat de la sauvegarde bloquante avec l'avertissement.

Je ne sais pas si cela est lié à un autre code de mon projet. besoin de temps pour vérifier. Veuillez ignorer avant que je découvre la cause.

Pour moi, ce journal apparaît dans la console chaque fois que j'utilise .then(), peu importe s'il est utilisé avec un objet mangouste ou tout autre objet non lié à la mangouste

Donc, selon les docs , je passe

'use strict';
var Promise = require('bluebird');

// Development specific configuration
// ==================================
module.exports = {
  // MongoDB connection options
  mongo: {
    uri: 'mongodb://localhost/fullstack-dev',
    options: {
      promiseLibrary: Promise
    }
  },
  // .. other config
};

Puis dans mon fichier principal faisant

'use strict';

// Set default node environment to development
process.env.NODE_ENV = process.env.NODE_ENV || 'development';
process.env.BLUEBIRD_DEBUG = 1;
var mongoose = require('mongoose');
var config = require(path.join(__dirname, 'server', 'config', 'environment'));

// Connect to database
var db = mongoose.connect(config.mongo.uri, config.mongo.options);
mongoose.connection.on('error', function(err) {
  console.error('MongoDB connection error: ' + err);
  process.exit(-1);
});

Et je reçois toujours l'avertissement de dépréciation lorsque je fais query.exec . Des suggestions sur ce que je fais mal?
[Edit : Ajout des versions mangouste et oiseau bleu]
J'utilise la mangouste ^4.6.1 , l'oiseau bleu ^3.4.6

Je reçois également un avertissement sur la mangouste 4.6.1 et le nœud 4.4.5

    var mongoose = require('mongoose');
    mongoose.Promise = global.Promise;
    mongoose.connect(dbConfig);
    var connection = mongoose.connection;

@manu29d semble que vous ne définissez pas mongoose.Promise = bluebird

@ vkarpov15 Je pense que je le suis. J'ai déclaré var Promise = au début du script de configuration, puis promiseLibrary: Promise plus tard. (Regardez le premier extrait de code dans les exemples)

De plus, j'ai essayé d'écrire promiseLibrary: require('bluebird') comme indiqué dans la documentation.

Je ne vois mongoose.Promise = require('bluebird') nulle part dans l'exemple de code que vous avez fourni. var Promise = require('bluebird'); n'est _pas_ correct.

@ vkarpov15 Je fais référence à http://mongoosejs.com/docs/promises.html#promises -for-the-mongodb-driver

Est-ce toujours valable ? Je n'ai pas le temps de vérifier dans le code si cette option ( promiseLibrary ) est toujours prise en charge dans la configuration ou a été supprimée.

Le réglage mongoose.Promise = global.Promise fonctionne cependant.

mongoose.Promise = global.Promise
avant que mongoose.connect ne fonctionne pour moi aussi.

Je n'utilise pas de promesses et j'appelle mongoose.Promise = global.Promise avant que la connexion ne fonctionne.

@ manu29d ces documents sont corrects, cependant, si vous les lisez réellement, vous verrez que l'option promiseLibrary n'affecte que le pilote mongodb sous-jacent, _pas_ les modèles mongoose.

@zubair-farooqui-10p le script ci-dessous ne déclenche pas l'avertissement pour moi en 4.5.9 ou 4.6.3 :

'use strict';

Error.stackTraceLimit = Infinity;

var assert = require('assert');
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/gh4291');
mongoose.set('debug', true);

var connection = mongoose.connection;

C'est vraiment ennuyeux de devoir ajouter cette ligne supplémentaire, y a-t-il un moyen pour mongoose de la réparer dans sa bibliothèque interne ? Merci!

Pas en général, car le fonctionnement du mécanisme de commutation de la bibliothèque promise de mongoose est assez différent de celui du pilote mongodb. Dans mongoose, c'est juste une propriété que vous pouvez définir sur l'objet global mongoose à tout moment, alors que dans le pilote mongodb, c'est une option de connexion, donc différentes connexions peuvent avoir différentes bibliothèques de promesses, mais vous ne pouvez définir la bibliothèque de promesses que lorsque vous vous connectez, pas après. Concilier ces différences n'est pas vraiment une priorité.

Pourquoi cela se produit lors de l'enregistrement d'un document contenant un tableau de chaînes, quelqu'un pourrait-il élaborer

Je l'obtiens également après avoir simplement appelé .createConnecton() . La chose amusante que j'utilise Q... MAIS ! Mais je préfère le faire après avoir établi une connexion, car je (et je suis presque sûr que tout le monde) préfère le faire dans le bloc de déclaration var. c'est à dire

var mongoose = require('mongoose'),
        connection1 = mongoose.createConnection(dbConn1Str),
        connection2 = mongoose.createConnection(dbConn2Str)
;
mongoose.Promise = Q.makePromise;

Au lieu de cela, pour me débarrasser de cet avertissement, je suis obligé de faire :

var mongoose = require('mongoose'),
        connection1, connection2
;
mongoose.Promise = Q.makePromise;
connection1 = mongoose.createConnection(dbConn1Str)
connection2 = mongoose.createConnection(dbConn2Str)

Ce n'est pas grave, mais assurément...

Ouais c'est la voie à suivre. Mongoose 4.x utilisera mpromise jusqu'à ce que vous lui disiez de ne pas le faire.

Je vois cela lors de l'utilisation d'un appel find() normal avec l'assistant de requête. Je n'utilise then nulle part.

BookStore.find().byUsingQueryHelper(1,2,3).lean().exec(function (err, docs) { ... })

Enregistrer:

Mangouste : librairies.find({ emplacement : { '$near' : [ 28.742712943610545, -13.865369983731426 ], '$maxDistance' : 0.0012556898446083817 } }, { limite : 10, champs : indéfinis })

(node:82366) DeprecationWarning : Mongoose : mpromise (la bibliothèque de promesses par défaut de mongoose) est obsolète, branchez plutôt votre propre bibliothèque de promesses : http://mongoosejs.com/docs/promises.html

@pronebird , malheureusement, c'est ainsi que exec() fonctionne en interne, les rappels à exec() passent en fait par une promesse. Faites simplement mongoose.Promise = global.Promise et vous ne devriez plus recevoir cet avertissement.

@pronebird j'ai eu la même erreur lors de la publication, et j'ai découvert que mon schéma a une valeur par défaut comme indiqué ci-dessous et ne correspond pas à ma valeur publiée ci-dessous
rôle : {
type : Chaîne,
énumération : ['Client', 'Administrateur'],
par défaut : 'Client'
}
Je poste role:admin et ça devrait être Admin
J'espère que cette réponse aidera quelqu'un. Merci

@Muhammedalbayati Je ne pense pas que votre problème ait quelque chose à voir avec ce problème particulier ? C'est juste un avertissement émis par Mongoose concernant les promesses.

@varunjayaraman vous avez raison, je dois mentionner ce qui suit
l'avertissement
DeprecationWarning : Mongoose : mpromise (la bibliothèque de promesses par défaut de mongoose) est obsolète, branchez plutôt votre propre bibliothèque de promesses : http://mongoosejs.com/docs/promises.html

s'en va en ajoutant mongoose.Promise = global.Promise; avant de se connecter à la bd
mongoose.connect('mongodb://localhost:27017/mydb');

@Muhammedalbayati Je pense que @vkarpov15 a expliqué pourquoi cet avertissement apparaît. Mongoose utilise des promesses en interne dans exec .

ES6 "yiled" ne fonctionne tout simplement pas avec la méthode doc.save après la mise à niveau de la mangouste vers la v.4.7.7.
Enfin c'est juste parce que mongoose.Promise = global.Promise . Après avoir supprimé ceci, il reste un avertissement

Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead:

Je suppose que [email protected] a son propre module de promesse. Est-ce correct??
Est-ce que quelqu'un le sait?

C'est la mangouste ajouter une bibliothèque es6-promise.

Donc question stupide !

PS : Enfourne ce putain d'avertissement dans ta chatte !

en tant que confrère russophone, je m'excuse pour le comportement de cet être inférieur qui vous a incité à ne pas traduire ce qu'il a écrit ici.

@ vkarpov15 J'ai essayé à la fois mongoose.Promise = global.Promise; et mongoose.Promise = require('bluebird'); .

Malheureusement, je reçois toujours l'avertissement de dépréciation.

_Est-ce qu'il y a quelque chose que je fais mal ?_

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;

mongoose.connect('mongodb://localhost/users_test');

mongoose.connection
  .once('open', () => {
    console.log('connectecd to db')
  })
  .on('error', (err) => {
    console.warn('Warning', err)
  });

@protoEvangelium Importez -vous des mangoustes ailleurs dans votre application ? Est-ce la première fois que la mangouste est utilisée ou ce fichier est-il importé dans un autre fichier ?

De plus, quelle version de mongoose/node utilisez-vous ?

@varunjayaraman Ce fichier n'est importé nulle part ailleurs. Cependant, j'importe mongoose dans mon fichier de schéma user.js, puis j'utilise ce schéma utilisateur dans certains de mes tests.

const mongoose = require('mongoose')
const Schema = mongoose.Schema
const UserSchema = new Schema({
  name: String,
})
const User = mongoose.model('user', UserSchema)
module.exports = User

nœud v7.0.0mangouste v4.8.1

@protoEvangelium recevez -vous l'avertissement dans votre application ou seulement dans vos tests ?

J'ai eu le même problème une fois - le coupable était un autre module, qui utilisait sa propre dépendance de mangouste. De tels modules ont quelque chose comme "mongoose": "^4.1.1" dans leur package.json, mais puisque ces modules sont mis à jour sur une base annuelle (le cas échéant) - ils n'ont pas la partie promesse de configuration. @protoEvangelium utilisez-vous d'autres modules ?

@SAudeLOG Merci pour la réponse

@varunjayaraman J'ai seulement commencé à tester l'ajout d'utilisateurs à Mongo en utilisant Mongoose et Mocha. C'est un projet barebones jusqu'à présent.

@Spown j'utilise:
"mocha": "^3.2.0", "mongoose": "^4.8.1", "nodemon": "^1.11.0"

Merci :)

@protoEvangelium attendez une minute, avez-vous essayé cela ?

const mongoose = require('mongoose')
mongoose.Promise = global.Promise // <--
const Schema = mongoose.Schema
const UserSchema = new Schema({
  name: String,
})
const User = mongoose.model('user', UserSchema)
module.exports = User

si vous créez un modèle à partir d'une instance de mangouste dont la promesse n'a pas été redéfinie - chaque requête sur ce modèle lancerait l'avertissement.

@Spown

Je suis tombé sur ce fil au bon moment. Je recevais le même avertissement chaque fois que j'enregistrais des informations. Il s'avère que je créais un modèle à partir d'une instance de mangouste et que je ne le redéfinissais pas. Exiger bluebird et le définir sur mongoose.Promise a résolu le message d'erreur.

Merci beaucoup!

@Spown Merci monsieur! C'était le problème. Fait intéressant, j'ai défini mongoose.Promise = global.Promise; dans mon fichier test_helper.js juste avant de me connecter à Mongoose. J'ai basculé le mongoose.Promise = global.Promise; vers mon fichier où j'ai défini le schéma et ça marche !!!! Plus d'avertissement de dépréciation 👍

const mongoose = require('mongoose')
mongoose.Promise = global.Promise;
const Schema = mongoose.Schema

J'obtiens ce problème lorsque j'utilise des virtuels "populables" dans mes schémas. En exécutant mon application avec --trace-deprecations , vous pouvez voir le coupable :

(node:8846) DeprecationWarning: Mongoose: mpromise (mongoose's default promise library) is deprecated, plug in your own promise library instead: http://mongoosejs.com/docs/promises.html
    at model.wrappedPointCut [as init] (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/services/model/applyHooks.js:141:26)
    at completeMany (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/query.js:1254:12)
    at Immediate.cb (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mongoose/lib/query.js:1117:13)
    at Immediate.<anonymous> (/Users/fleavamini/Projects/stellium/stellium-express/node_modules/mquery/lib/utils.js:137:16)
    at runCallback (timers.js:651:20)
    at tryOnImmediate (timers.js:624:5)
    at processImmediate [as _immediateCallback] (timers.js:596:5)

J'ai défini la promesse (notez que j'utilise TypeScript):

import * as mongoose from "mongoose";
(<any>mongoose).Promise = global.Promise;
mongoose.connect('mongodb://localhost/blah')

Des idées? Dois-je définir la promesse sur chaque modèle qui utilise des virtuels "peuplables" ? Attends, je vais vraiment essayer ça et je reviens avec ce que ça s'est passé.

D'accord, après quelques retouches, j'ai compris que je devais toujours définir le Promise sur mon schéma même si je l'avais défini dans le index de mon serveur.

Dans mon cas, la collection website_pages a été la première collection à être interrogée par mon système, définir le mongoose.Promise sur global.Promise sur ce schéma seul a résolu le problème et j'étais Il n'est pas nécessaire de le définir dans tous les schémas.

Pourquoi ne pas utiliser les promesses ES6 ? Ne sont-ils pas disponibles partout maintenant ?

mongoose.Promise = Promise; // eh?

Merci @Spown , j'ai fait face au même avertissement de dépréciation depuis que j'ai mis mongoose.Promise = global.Promise après l'importation du modèle. Maintenant, l'avertissement de dépréciation a disparu.

Déclarer mongoose.Promise = global.Promise dans le fichier modèle comme mentionné par @Spown fonctionne. Cela est dû à la mise en cache des modules requis par le nœud . Cela semble cependant inconstant. N'y a-t-il pas un moyen de s'assurer que test_helpers.js est chargé en premier afin que je puisse définir la fonction de promesse de mangouste dans ce fichier ?

N'y a-t-il pas un moyen de s'assurer que...

personnellement, je require mongoose une seule fois dans mes projets, puis je le mets dans un objet Singleton global et je l'utilise partout à toutes les fins de base de données. Pas exactement gracieux, mais surtout à l'épreuve des balles. et je l'ai fait bien avant la dépréciation simplement parce que si vous utilisez une connexion personnalisée, ce que je fais (une connexion établie via mongoose.createConnection() au lieu de mongoose.connect() ) - vous devez créer des modèles de l'instance de mangouste liée à cette connexion. Sinon, cela ne fonctionnera tout simplement pas, ce qui est bien pire qu'un avertissement embêtant.

ouais je fais la même chose que @Spown. Ce n'est certainement pas l'idéal, mais c'est le seul moyen de garder la mangouste rétrocompatible jusqu'à la prochaine version majeure lorsque nous pourrons complètement déprécier mpromise

libs/mongoose.js

import mongoose from 'mongoose'; // real mongoose only be required once here 

mongoose.Promise = global.Promise; // so that you dont have to do this on every require
const Schema = mongoose.Schema;

export {
  mongoose as default, // kind of singleton
  mongoose,
  Schema,
};

index.js

import mongoose from './libs/mongoose';
mongoose.connect(process.env.MONGODB_URI);

modèles/user.js

import {mongoose, Schema} from '../libs/mongoose';

export default mongoose.model('User', new Schema({
  name: String,
  password: String,
}));

Les appels @howard require() sont mis en cache.

Donc, si je comprends bien, je dois définir la promesse avant chaque déclaration de schéma au lieu de le faire à un seul endroit (par exemple dans mon fichier d'index ou là où je configure la connexion)
Ce n'est pas une bonne pratique, il vaut la peine d'envisager de le changer en une fonction, quelque chose comme :
mongoose.setPromise(global.Promise);

@sh-guti je pense que oui, j'ai eu le même problème et ce morceau de code le résout.

À ce stade, je ne sais pas si utiliser des rappels ou des promesses. MDR.

Utiliser

mongoose.createConnection(URI)

Quelqu'un peut-il expliquer pourquoi sur Terre la mangouste nie l'existence des promesses indigènes et ne peut pas les utiliser hors de la boîte?

Rétrocompatibilité. Mongoose 4.x a existé pendant plus d'un an avant la sortie du nœud 4. Nous allons basculer avec la prochaine version de rupture vers l'arrière.

Quand cela sera-t-il ?

mongoose.createConnection(URI) provoque un bogue très étrange avec Mongoose , des heures de débogage avec des requêtes ne fonctionnant pas . est finalement retourné à

mongoose.connect(process.env.MONGODB); de mongoose.createConnection (process.env.MONGODB)

en remarque, cela a arrêté l'avertissement de dépréciation .. mais a tout arrêté de fonctionner ...

@MickL , nous aurons un rc0 dans les prochaines semaines, suivez la mangouste sur twitter ou rejoignez la chaîne slack pour les mises à jour

Cette page vous a été utile?
0 / 5 - 0 notes