¿Cuál es el error de Mongoose? ¿Falló la conversión a ObjectId para el valor XXX en la ruta "_id"?

Al enviar una solicitud a /customers/41224d776a326fb40f000001y un documento con _id 41224d776a326fb40f000001no existe, doces nully estoy devolviendo un 404:

  Controller.prototype.show = function(id, res) {
    this.model.findById(id, function(err, doc) {
      if (err) {
        throw err;
      }
      if (!doc) {
        res.send(404);
      }
      return res.send(doc);
    });
  };

Sin embargo, cuando _idno coincide con lo que Mongoose espera como "formato" (supongo), por ejemplo, GET /customers/foose devuelve un error extraño:

CastError: Error de conversión a ObjectId para el valor "foo" en la ruta "_id".

Entonces, ¿qué es este error?

El findByIdmétodo de Mongoose envía el idparámetro al tipo de _idcampo del modelo para que pueda consultar correctamente el documento correspondiente. Este es un ObjectId pero "foo"no es un ObjectId válido, por lo que la conversión falla.

Esto no sucede 41224d776a326fb40f000001porque esa cadena es un ObjectId válido.

Una forma de resolver esto es agregar una verificación antes de su findByIdllamada para ver si ides un ObjectId válido o no así:

if (id.match(/^[0-9a-fA-F]{24}$/)) {
  // Yes, it's a valid ObjectId, proceed with `findById` call.
}

Utilice funciones existentes para comprobar ObjectID.

var mongoose = require('mongoose');
mongoose.Types.ObjectId.isValid('your id here');

¿Estás analizando esa cadena como ObjectId?

Aquí en mi aplicación, lo que hago es:

ObjectId.fromString( myObjectIdString );

Tengo el mismo problema, agrego
_id: String .in esquema y luego comienza a funcionar

Tuve que mover mis rutas por encima de otras rutas que están capturando los parámetros de la ruta:

// require express and express router

const express = require("express");
const router = express.Router();

// move this `/post/like` route on top

router.put("/post/like", requireSignin, like);

// keep the route with route parameter `/:postId` below regular routes

router.get("/post/:postId", singlePost);

 if(mongoose.Types.ObjectId.isValid(userId.id)) {
        User.findById(userId.id,function (err, doc) {
            if(err) {
                reject(err);
            } else if(doc) {
                resolve({success:true,data:doc});
            } else {
                reject({success:false,data:"no data exist for this id"})

            }
        });
        } else {
            reject({success:"false",data:"Please provide correct id"});
        }

lo mejor es verificar la validez

En mi caso, tuve que agregar _id: Objecta mi esquema, y ​​luego todo funcionó bien.

También puede usar ObjectId.isValid como el siguiente:

if (!ObjectId.isValid(userId)) return Error({ status: 422 })

//Use following to check if the id is a valid ObjectId?

var valid = mongoose.Types.ObjectId.isValid(req.params.id);
if(valid)
{
  //process your code here
} else {
  //the id is not a valid ObjectId
}

Me enfrenté a algo similar recientemente y lo resolví detectando el error para averiguar si se trataba de un error de Mongoose ObjectId.

app.get("/:userId", (req, res, next) => {
    try {
        // query and other code here
    } catch (err) {
        if (err.kind === "ObjectId") {
            return res.status(404).json({
                errors: [
                    {
                        msg: "User not found",
                        status: "404",
                    },
                ],
            });
        }
        next(err);
    }
});

A partir del 19 de noviembre de 2019

Puedes usar isValidObjectId(id) desde la versión 5.7.12 de mangosta

https://mongoosejs.com/docs/api/mongoose.html#mongoose_Mongoose-isValidObjectId

Fui con una adaptación de la solución @gustavohenke, implementando cast ObjectId en un try-catch envuelto alrededor del código original para aprovechar el error de conversión de ObjectId como método de validación.

Controller.prototype.show = function(id, res) {
  try {
    var _id = mongoose.Types.ObjectId.fromString(id);



    // the original code stays the same, with _id instead of id:

    this.model.findById(_id, function(err, doc) {
      if (err) {
        throw err;
      }
      if (!doc) {
        res.send(404);
      }
      return res.send(doc);
    });



  } catch (err) {
    res.json(404, err);
  }
};

Esta es una pregunta antigua, pero también puede usar el paquete express-validator para verificar los parámetros de solicitud

express-validator versión 4 (más reciente):

validator = require('express-validator/check');

app.get('/show/:id', [

    validator.param('id').isMongoId().trim()

], function(req, res) {

    // validation result
    var errors = validator.validationResult(req);

    // check if there are errors
    if ( !errors.isEmpty() ) {
        return res.send('404');
    }

    // else 
    model.findById(req.params.id, function(err, doc) { 
        return res.send(doc);
    });

});

express-validator versión 3:

var expressValidator = require('express-validator');
app.use(expressValidator(middlewareOptions));

app.get('/show/:id', function(req, res, next) {

    req.checkParams('id').isMongoId();

    // validation result
    req.getValidationResult().then(function(result) {

        // check if there are errors
        if ( !result.isEmpty() ) {
            return res.send('404');
        }

        // else
        model.findById(req.params.id, function(err, doc) {
            return res.send(doc);
        });

    });

});

Utilice siempre mongoose.Types.ObjectId('your id')para las condiciones en su consulta, validará el campo de identificación antes de ejecutar su consulta, como resultado, su aplicación no se bloqueará.

O puedes hacer esto

var ObjectId = require('mongoose').Types.ObjectId; var objId = new ObjectId( (param.length < 12) ? "123456789012" : param );

como se menciona aquí, el método de búsqueda de Mongoose con $ o condición no funciona correctamente

La forma en que soluciono este problema es transformando la identificación en una cadena

me gusta elegante con comillas invertidas: `${id}`

esto debería solucionar el problema sin gastos generales

ObjectId se compone de las siguientes cosas.

1. un valor de 4 bytes que representa los segundos desde la época de Unix
2. un valor aleatorio de 5 bytes (ID de máquina 3 bytes e ID de procesador 2 bytes)
3. un contador de 3 bytes, comenzando con un valor aleatorio.

La forma correcta de validar si el objectId es válido es mediante el uso del método estático de la propia clase ObjectId.

mongoose.Types.ObjectId.isValid (sample_object_id)

Convertir cadena en ObjectId

import mongoose from "mongoose"; // ES6 or above
const mongoose = require('mongoose'); // ES5 or below

let userid = _id
console.log(mongoose.Types.ObjectId(userid)) //5c516fae4e6a1c1cfce18d77

Detección y corrección del error ObjectID

Me encontré con este problema al intentar eliminar un elemento con mangosta y obtuve el mismo error. Después de mirar la cadena de retorno, encontré que había algunos espacios adicionales dentro de la cadena devuelta que me causaron el error. Entonces, apliqué algunas de las respuestas proporcionadas aquí para detectar la identificación errónea y luego eliminé los espacios adicionales de la cadena. Aquí está el código que me funcionó para finalmente resolver el problema.

const mongoose = require("mongoose");
mongoose.set('useFindAndModify', false);  //was set due to DeprecationWarning: Mongoose: `findOneAndUpdate()` and `findOneAndDelete()` without the `useFindAndModify`



app.post("/delete", function(req, res){
  let checkedItem = req.body.deleteItem;
  if (!mongoose.Types.ObjectId.isValid(checkedItem)) {
    checkedItem = checkedItem.replace(/\s/g, '');
  }

  Item.findByIdAndRemove(checkedItem, function(err) {
    if (!err) {
      console.log("Successfully Deleted " + checkedItem);
        res.redirect("/");
      }
    });
});

Esto funcionó para mí y supongo que si otros elementos comienzan a aparecer en la cadena de devolución, se pueden eliminar de manera similar.

Espero que esto ayude.

Solucioné este problema cambiando el orden de las rutas.

Estaba teniendo problemas con esto y lo arreglé mongoose.ObjectId(id)sinTypes