Mongoose.js: buscar usuario por nombre de usuario LIKE valor

Me gusta ir a buscar un usuario en mongoDb buscando un usuario llamado valor. El problema con:

username: 'peter'

es que no lo encuentro si el nombre de usuario es "Peter", o "Peter" .. o algo así.

Entonces quiero hacer como sql

SELECT * FROM users WHERE username LIKE 'peter'

¿Espero que obtengan lo que estoy pidiendo?

Corto: 'campo LIKE value' en mongoose.js / mongodb

Para aquellos que buscaban una solución aquí está:

var name = 'Peter';
model.findOne({name: new RegExp('^'+name+'$', "i")}, function(err, doc) {
  //Do your action here..
});

Tuve problemas con esto recientemente, uso este código y funciona bien para mí.

var data = 'Peter';

db.User.find({'name' : new RegExp(data, 'i')}, function(err, docs){
    cb(docs);
});

Uso directamente /Peter/itrabajo, pero uso '/'+data+'/i'y no trabajo para mí.

db.users.find( { 'username' : { '$regex' : req.body.keyWord, '$options' : 'i' } } )

collection.findOne({
    username: /peter/i
}, function (err, user) {
    assert(/peter/i.test(user.username))
})

router.route('/product/name/:name')
.get(function(req, res) {

    var regex = new RegExp(req.params.name, "i")
    ,   query = { description: regex };

    Product.find(query, function(err, products) {
        if (err) {
            res.json(err);
        }

        res.json(products);
    });

});  

Deberías usar una expresión regular para eso.

db.users.find({name: /peter/i});

Sin embargo, tenga cuidado de que esta consulta no utilice index.

doc mangosta para encontrar. mongodb doc para regex.

var Person = mongoose.model('Person', yourSchema);
// find each person with a name contains 'Ghost'
Person.findOne({ "name" : { $regex: /Ghost/, $options: 'i' } },
    function (err, person) {
             if (err) return handleError(err);
             console.log('%s %s is a %s.', person.name.first, person.name.last, person.occupation);
});

Tenga en cuenta que el primer argumento se pasa a mongoose.findOnela función: { "name" : { $regex: /Ghost/, $options: 'i' } }, "name"es el campo del documento que está buscando, "Ghost"es la expresión regular, "i"es para buscar coincidencias sin insensibles. Espero que esto te ayudará.

La siguiente consulta encontrará los documentos con la cadena requerida sin distinción y con ocurrencia global también

var name = 'Peter';
    db.User.find({name:{
                         $regex: new RegExp(name, "ig")
                     }
                },function(err, doc) {
                                     //Your code here...
              });

Esto es lo que estoy usando.

module.exports.getBookByName = function(name,callback){
    var query = {
            name: {$regex : name}
    }
    User.find(query,callback);
}

Aquí mi código con expressJS:

router.route('/wordslike/:word')
    .get(function(request, response) {
            var word = request.params.word;       
            Word.find({'sentence' : new RegExp(word, 'i')}, function(err, words){
               if (err) {response.send(err);}
               response.json(words);
            });
         });

si quiero consultar todos los registros en alguna condición, puedo usar esto:

if (userId == 'admin')
  userId = {'$regex': '.*.*'};
User.where('status', 1).where('creator', userId);

Simplemente complementando la respuesta de @PeterBechP.

No olvides escapar de los caracteres especiales. https://stackoverflow.com/a/6969486

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

var name = 'Peter+with+special+chars';

model.findOne({name: new RegExp('^'+escapeRegExp(name)+'$', "i")}, function(err, doc) {
  //Do your action here..
});

Esta es mi solución para convertir cada valor en un req.body en un parámetro LIKE de mangosta :

let superQ = {}

Object.entries({...req.body}).map((val, i, arr) => {
    superQ[val[0]] = { '$regex': val[1], '$options': 'i' }
})

User.find(superQ)
  .then(result => {
    res.send(result)})
  .catch(err => { 
    res.status(404).send({ msg: err }) })