Mongoose: Advertencia de obsolescencia

Hmm, ¿estás usando promesas en alguna parte? No debería recibir esta advertencia a menos que use promesas...

nop, no estoy usando promesas

Acabo de empezar a tener este problema también. ¡No usar promesas que yo sepa!

Resolví esa advertencia haciendo

mongoose.Promise = global.Promise;

Justo antes de llamar a 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;
};

Sí, se supone que esta advertencia le indica que cambie la lib de promesa predeterminada de mangostas si está usando promesas, pero no debería suceder a menos que llame a .then en algún lugar

Lo obtengo, pero solo lo obtengo donde guardo un objeto, luego lo modifico en la devolución de llamada y lo guardo nuevamente.

Probé el enfoque @SaudelOG para asignar una promesa a la mangosta antes de que la mangosta se conecte, pero sigo recibiendo este error.

Estoy usando funciones asincrónicas es7, y mi código está bloqueado cuando intento Model.findOne({})

La solución que proporciona @SAudelOG funciona. Al igual que @IrishAdo , solo obtengo esto cuando también guardo un objeto. Tal vez se deba a uno de los complementos de mongoose que estoy usando usando la biblioteca de promesas de Bluebird.

Aquí hay una lista de dependencias que estoy usando

  "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"
  }

No estoy usando complementos ni promesas y también recibo esta advertencia (en [email protected]).

Ejecutando mi aplicación con "--trace-deprecation" tengo:

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)

Tengo el mismo problema, si sirve de ayuda, se activa específicamente cuando intento crear documentos que tienen una serie de subdocumentos dentro de ellos, algo así como:

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

mySchema.create(data, cb)

No ocurre con otras colecciones que no tienen subdocumentos, ni siquiera ocurre si emito la declaración de creación sin los datos del subdoc, así:

var data = {
  field: 'value'
} 

mySchema.create(data, cb)

_Nota:_ mongoose.Promise = global.Promise me resolvió el problema de advertencia

Experimento la misma advertencia de depreciación cuando uso remove() en un documento. No estoy usando promesas aquí ni en ningún otro lugar de mi código.

Acabo de recibir este error cuando uso Model.create(objects, callback); , ¿quizás esta solución aún no se ha publicado en npm?

Conseguir esto, me alegra leerlo, no es alarmante. Examinaré esto más de cerca para ayudar a depurar cuando suceda.

Obteniendo esto también, y no estoy usando promesas de mangosta en ninguna parte.

Pude rastrearlo hasta una llamada model.save dentro de una devolución de llamada de la biblioteca en los encabezados , y el modelo se creó fuera de la devolución de llamada, antes de que se llamara, en caso de que ayude a alguien. Poner la creación del modelo y guardar la llamada dentro de la devolución de llamada no hace ninguna diferencia.

Enfrentar este problema en el nodo v4.4.6 mientras que en v4.4.2 parece funcionar

Ejemplo de código de @SKatiyar , por favor

lo mismo conmigo, recibo este mensaje después de invocar el método save(), suficiente para que me importe

¡Esto funciona! Antes mongoose.connect(MONGO_URI); agregar mongoose.Promise = global.Promise;

El siguiente código es suficiente para reproducir en mi extremo:

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'

Lo extraño que puedo ver aquí es que usar newModel.save(callback) todavía devuelve una promesa (o supongo que es una promesa, ya que el tipo de .then es 'function' ). ¿Es ese el comportamiento esperado?

Aquí están mis versiones:
Nodo: v6.3.1
Mangosta: v4.5.8

Avíseme si necesita cualquier otra información de mí.

@dvlsg sí, ese es el comportamiento esperado actualmente, guardar siempre devolverá una promesa incluso si pasa una devolución de llamada

Bueno, supongo que eso al menos explicaría por qué las personas ven la advertencia de promesa incluso cuando no creen que estén usando promesas.

Eso lo explica todo... Estoy un poco paranoico y quería deshacerme de todas las advertencias 💃

Es mi culpa, sí, .save() devuelve una promesa, por lo que se esperaba, pero aún así, la advertencia me hizo dudar. http://mongoosejs.com/docs/promises.html (solo tenía que leer el primer párrafo 🎱)

Entonces .save() devuelve una promesa, pero no debería recibir esta advertencia a menos que llame a .then() . Si recibe esta advertencia sin llamar a .then() en su código, eso significa que mongoose está usando una promesa en algún lugar donde no debería, así que abra un problema separado con ejemplos de código: +1:

En mi humilde opinión, este mensaje debería ser un error ("las cosas no funcionan") en lugar de una advertencia ("preste atención, pero debería funcionar"), ya que en realidad se devuelve como un error en la devolución de llamada.

Me encontré con este problema y el método aModel.save() no funcionó para ponerlo en MongoDB. Tomó algún tiempo encontrar la raíz de este problema. Después de aplicar "mongoose.Promise = global.Promise;", tuvo éxito.

Estaba usando "mangosta": "^4.5.9".

Guardar debería funcionar bien con la biblioteca de promesa predeterminada, ¿puede proporcionar un ejemplo de código?

@vkarpov15

Estás bien. Acabo de intentar y no pude recrear desde cero el resultado de guardado de bloqueo con la advertencia.

No estoy seguro si está relacionado con otro código en mi proyecto. necesita algo de tiempo para comprobar. Ignóralo antes de que averigüe la causa.

Para mí, este registro aparece en la consola cada vez que uso .then(), no importa si se usa con un objeto mangosta o cualquier otro objeto no relacionado con mangosta

Entonces, según los documentos , estoy pasando

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

Luego, en mi archivo principal haciendo

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

Y sigo recibiendo la advertencia de desaprobación cuando hago query.exec . ¿Alguna sugerencia sobre lo que estoy haciendo mal?
[Editar: agregar versiones de mangosta y pájaro azul]
Estoy usando mangosta ^4.6.1 , pájaro azul ^3.4.6

También recibo una advertencia en mangosta 4.6.1 y nodo 4.4.5

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

@ manu29d parece que no estás configurando mongoose.Promise = bluebird

@vkarpov15 Creo que lo soy. Declaré var Promise = al comienzo del script de configuración y luego promiseLibrary: Promise más adelante. (Mira el primer fragmento de código en los ejemplos)

Además, intenté escribir promiseLibrary: require('bluebird') como se indica en los documentos.

No veo mongoose.Promise = require('bluebird') en ninguna parte del ejemplo de código que proporcionó. var Promise = require('bluebird'); _no_ está bien.

@ vkarpov15 Me refiero a http://mongoosejs.com/docs/promises.html#promises -for-the-mongodb-driver

¿Sigue siendo válido? No tengo tiempo para verificar el código si esta opción ( promiseLibrary ) aún es compatible con la configuración o si se eliminó.

Sin embargo, configurar mongoose.Promise = global.Promise funciona.

mongoose.Promise = global.Promise
antes de que mongoose.connect también me funcione.

No estoy usando promesas y llamando a mongoose.Promise = global.Promise antes de que funcione la conexión.

@ manu29d esos documentos son correctos, sin embargo, si realmente los lee, verá que la opción promiseLibrary solo afecta al controlador mongodb subyacente, _no_ a los modelos mongoose.

@ zubair-farooqui-10p el siguiente script no activa la advertencia para mí en 4.5.9 o 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;

Es realmente molesto tener que agregar esta línea adicional, ¿hay alguna forma de que Mongoose lo arregle en su biblioteca interna? ¡Gracias!

No en general, porque la forma en que funciona el mecanismo de cambio de lib de la promesa de mongoose es bastante diferente de cómo funciona el controlador mongodb. En mongoose es solo una propiedad que puede configurar en el objeto global de mongoose en cualquier momento, mientras que en el controlador mongodb es una opción de conexión, por lo que diferentes conexiones pueden tener diferentes bibliotecas de promesa, pero solo puede configurar la biblioteca de promesa cuando se está conectando, no después. No es realmente una prioridad reconciliar estas diferencias atm.

¿Por qué sucede esto al guardar un documento que tiene una matriz de cadenas? ¿Alguien podría explicarlo?

También lo entiendo después de llamar a .createConnecton() . Lo curioso es que sí uso Q... ¡PERO! Pero prefiero hacerlo después de establecer una conexión, porque yo (y estoy bastante seguro de que todos) prefiero hacerlo en el bloque de declaración var. es decir

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

En cambio, para deshacerme de esta advertencia, me veo obligado a hacer:

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

No es gran cosa, pero srsly...

Sí, ese es el camino a seguir. Mongoose 4.x usará mpromise hasta que le digas que no lo haga.

Veo esto cuando uso la llamada find() regular con el asistente de consultas. No uso then ninguna parte.

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

Tronco:

Mongoose: librerías.find({ ubicación: { '$near': [ 28.742712943610545, -13.865369983731426 ], '$maxDistance': 0.0012556898446083817 } }, {límite: 10, campos: indefinido })

(nodo: 82366) DeprecationWarning: Mongoose: mpromise (la biblioteca de promesas predeterminada de mongoose) está en desuso, conecte su propia biblioteca de promesas en su lugar: http://mongoosejs.com/docs/promises.html

@pronebird desafortunadamente así es como exec() funciona internamente, las devoluciones de llamada a exec() en realidad pasan por una promesa. Simplemente haga mongoose.Promise = global.Promise y ya no debería recibir esa advertencia.

@pronebird Recibí el mismo error cuando publiqué y descubrí que mi esquema tiene un valor predeterminado como se muestra a continuación y no coincide con el valor publicado a continuación
papel: {
tipo: Cadena,
enumeración: ['Cliente', 'Administrador'],
predeterminado: 'Cliente'
}
Publico role:admin y debería ser Admin
Espero que esta respuesta ayude a alguien. Gracias

@Muhammedalbayati No creo que su problema tenga nada que ver con este problema en particular. Es solo una advertencia emitida por Mongoose con respecto a las promesas.

@varunjayaraman tienes razón, debo mencionar lo siguiente
la advertencia
DeprecationWarning: Mongoose: mpromise (la biblioteca de promesas predeterminada de mongoose) está en desuso, conecte su propia biblioteca de promesas en su lugar: http://mongoosejs.com/docs/promises.html

desaparece agregando mongoose.Promise = global.Promise; antes de conectarse a la base de datos
mongoose.connect('mongodb://localhost:27017/mydb');

@Muhammedalbayati Creo que @vkarpov15 explicó por qué aparece esta advertencia. Mongoose usa promesas internamente dentro exec .

ES6 "yiled" simplemente no funciona con el método doc.save después de actualizar mongoose a v.4.7.7.
Finalmente es solo porque mongoose.Promise = global.Promise . Después de eliminar esto, sigue advirtiendo

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

Supongo que [email protected] tiene su propio módulo de promesa. ¿¿Está bien??
¿Alguien lo sabe?

Es mangosta agregar una librería es6-promise.

¡Qué asunto tan estúpido!

PD: ¡Métete esa puta advertencia en el coño!

como compañero de habla rusa, me disculpo por el comportamiento que este ser menor ha mostrado y le insto a que no traduzca lo que ha escrito aquí.

@ vkarpov15 He probado tanto mongoose.Promise = global.Promise; como mongoose.Promise = require('bluebird'); .

Desafortunadamente, sigo recibiendo la advertencia de desaprobación.

_¿Hay algo que esté haciendo 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 ¿Está importando mangosta en otro lugar de su aplicación? ¿Es esta la primera vez que se usa mongoose o este archivo se importa a otro archivo?

Además, ¿qué versión de mongoose/node estás usando?

@varunjayaraman Este archivo no se importa en ningún otro lugar. Sin embargo, estoy importando mongoose en mi archivo de esquema user.js y luego uso ese esquema de usuario en algunas de mis pruebas.

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

nodo v7.0.0mangosta v4.8.1

@protoEvangelium , ¿recibe la advertencia en su aplicación o solo en sus pruebas?

Tuve el mismo problema una vez: el culpable fue otro módulo, que usó su propia dependencia de mangosta. Dichos módulos tienen algo como "mongoose": "^4.1.1" en su paquete.json, pero dado que estos módulos se actualizan anualmente (si es que lo hacen), carecen de la parte de configuración de promesa. @protoEvangelium , ¿estás usando otros módulos?

@SAudelOG Gracias por la respuesta

@varunjayaraman Solo comencé a probar agregar usuarios a Mongo usando Mongoose y Mocha. Es un proyecto barebones hasta ahora.

@Spown estoy usando:
"mocha": "^3.2.0", "mongoose": "^4.8.1", "nodemon": "^1.11.0"

Gracias :)

@protoEvangelium espera un minuto, ¿probaste esto?

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 crea un modelo a partir de una instancia de mangosta cuya promesa no se redefinió, cada consulta en este modelo arrojaría la advertencia.

@Spown

Me encontré con este hilo en el momento adecuado. Recibía la misma advertencia cada vez que guardaba información. Resulta que estaba creando un modelo a partir de una instancia de mongoose y no lo estaba redefiniendo. Requerir bluebird y configurarlo en mongoose. Promise resolvió el mensaje de error.

¡Muchas gracias!

@Spown ¡ Gracias, señor! Ese era el problema. Curiosamente, definí mongoose.Promise = global.Promise; en mi archivo test_helper.js justo antes de conectarme a Mongoose. ¡Cambié el mongoose.Promise = global.Promise; a mi archivo donde definí el esquema y funciona! No más advertencia de desaprobación 👍

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

Recibo este problema cuando uso virtuales "poblables" en mis esquemas. Ejecutando mi aplicación con --trace-deprecations , puedes ver al culpable:

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

He establecido la promesa (tenga en cuenta que estoy usando TypeScript):

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

¿Algunas ideas? ¿Debo establecer la promesa en cada modelo que usa virtuales "poblables"? Espera, de hecho voy a probar eso y volveré con cómo me fue.

De acuerdo, después de algunos retoques, descubrí que todavía necesito configurar Promise en mi esquema incluso si lo configuré en index de mi servidor.

En mi caso, la colección website_pages fue la primera colección en ser consultada por mi sistema, establecer mongoose.Promise en global.Promise solo en este esquema solucionó el problema y estaba No es necesario configurarlo en todos los esquemas.

¿Por qué no usar ES6 Promises? ¿No están disponibles en todas partes ahora?

mongoose.Promise = Promise; // eh?

Gracias @Spown , enfrenté la misma advertencia de desaprobación desde que puse mongoose.Promise = global.Promise después de importar el modelo. Ahora la advertencia de desaprobación se ha ido.

Declarar mongoose.Promise = global.Promise en el archivo modelo como lo menciona @Spown funciona. Esto se debe al almacenamiento en caché del nodo de los módulos necesarios . Aunque esto parece voluble. ¿No hay una forma de garantizar que test_helpers.js se cargue primero para que pueda configurar la función de promesa de mongoose en este archivo?

¿No hay una manera de asegurar que...

personalmente, require mongoose solo una vez en mis proyectos, luego lo coloco en un objeto Singleton global y lo uso en todas partes para todos los propósitos de DB. No exactamente elegante, pero sobre todo a prueba de balas. y lo he estado haciendo mucho antes de la desaprobación simplemente porque si usa una conexión personalizada, lo cual hago (una conexión realizada a través mongoose.createConnection() en lugar de mongoose.connect() ), tiene que crear modelos de la instancia de mangosta vinculada a esta conexión. De lo contrario, simplemente no funcionará en absoluto, lo que es mucho peor que una advertencia molesta.

sí, hago lo mismo que @Spown. Ciertamente no es lo ideal, pero es la única forma de mantener mongoose compatible con versiones anteriores hasta el próximo lanzamiento principal, cuando podemos dejar de usar mpromise por completo.

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

índice.js

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

modelos/usuario.js

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

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

Las llamadas @howard require() se almacenan en caché.

Entonces, si entiendo correctamente, necesito establecer la promesa antes de cada declaración de esquema en lugar de hacerlo solo en un lugar (por ejemplo, en mi archivo de índice o donde estoy configurando la conexión)
Esta no es una buena práctica, vale la pena considerar cambiarla a una función, algo como:
mongoose.setPromise(global.Promise);

@sh-guti, creo que sí, tuve el mismo problema y ese código lo resolvió.

En este punto, no sé si usar devoluciones de llamada o promesas. JAJAJA.

Usar

mongoose.createConnection(URI)

¿Alguien puede explicar por qué la mangosta de la Tierra niega la existencia de Promesas nativas y no puede usarlas listas para usar?

Compatibilidad al revés. Mongoose 4.x existió durante más de un año antes de que se lanzara el nodo 4. Cambiaremos con el próximo lanzamiento de ruptura hacia atrás.

¿Cuándo será esto?

mongoose.createConnection(URI) causa un error muy extraño con Mongoose, horas de depuración con consultas que no funcionan. finalmente volvió a

mangosta.conectar(proceso.env.MONGODB); de mongoose.createConnection(process.env.MONGODB)

como nota al margen, detuvo la advertencia de depreciación... pero dejó de funcionar todo...

@MickL tendremos un rc0 en las próximas semanas, sigue a mongoose en twitter o únete al canal de slack para actualizaciones