Qual è l'errore di Mongoose trasmesso a ObjectId non riuscito per il valore XXX nel percorso "_id"?

Quando si invia una richiesta a /customers/41224d776a326fb40f000001e un documento con _id 41224d776a326fb40f000001non esiste, docè nulle sto restituendo 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);
    });
  };

Tuttavia, quando _idnon corrisponde a ciò che Mongoose si aspetta come "formato" (suppongo), ad esempio con GET /customers/foouno strano errore viene restituito:

CastError: Cast a ObjectId non riuscito per il valore "foo" nel percorso "_id".

Allora qual è questo errore?

Il findByIdmetodo di Mongoose esegue il cast del idparametro sul tipo di _idcampo del modello in modo che possa eseguire correttamente una query per il documento corrispondente. Questo è un ObjectId ma "foo"non è un ObjectId valido, quindi il cast non riesce.

Ciò non accade 41224d776a326fb40f000001perché quella stringa è un ObjectId valido.

Un modo per risolvere questo problema è aggiungere un controllo prima della findByIdchiamata per vedere se idè un ObjectId valido o meno:

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

Usa le funzioni esistenti per controllare ObjectID.

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

Stai analizzando quella stringa come ObjectId?

Qui nella mia domanda, quello che faccio è:

ObjectId.fromString( myObjectIdString );

Ho lo stesso problema che aggiungo
_id: String. Nello schema, quindi inizia a funzionare

Ho dovuto spostare i miei percorsi sopra altri percorsi che stanno catturando i parametri del percorso:

// 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"});
        }

la cosa migliore è verificare la validità

Nel mio caso, ho dovuto aggiungere _id: Objectal mio schema e poi tutto ha funzionato bene.

Puoi anche utilizzare ObjectId.isValid come segue:

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
}

Mi sono trovato di fronte a qualcosa di simile di recente e l'ho risolto rilevando l'errore per scoprire se si tratta di un errore di 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 partire dal 19 novembre 2019

Puoi usare isValidObjectId(id)dalla versione mongoose 5.7.12

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

Sono andato con un adattamento della soluzione @gustavohenke, implementando cast ObjectId in un try-catch avvolto attorno al codice originale per sfruttare il fallimento del casting ObjectId come metodo di convalida.

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

Questa è una vecchia domanda, ma puoi anche usare il pacchetto express-validator per controllare i parametri della richiesta

express-validator versione 4 (ultima):

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

    });

});

Usa sempre mongoose.Types.ObjectId('your id')per le condizioni nella tua query, convaliderà il campo id prima di eseguire la query, di conseguenza la tua app non andrà in crash.

O puoi farlo

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

come menzionato qui, il metodo find di Mongoose con $ o condition non funziona correttamente

Il modo in cui risolvo questo problema sta trasformando l'id in una stringa

mi piace fantasia con il backtick: `${id}`

questo dovrebbe risolvere il problema senza sovraccarico

ObjectId è composto dalle seguenti cose.

1. un valore di 4 byte che rappresenta i secondi trascorsi dall'epoca Unix
2. un valore casuale di 5 byte (ID macchina 3 byte e ID processore 2 byte)
3. un contatore a 3 byte, che inizia con un valore casuale.

Il modo corretto per verificare se objectId è valido è utilizzare il metodo statico dalla stessa classe ObjectId.

mongoose.Types.ObjectId.isValid (sample_object_id)

Cast stringa a 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

Rilevamento e correzione dell'errore ObjectID

Mi sono imbattuto in questo problema durante il tentativo di eliminare un elemento utilizzando mangusta e ho ricevuto lo stesso errore. Dopo aver esaminato la stringa di ritorno, ho scoperto che c'erano degli spazi extra all'interno della stringa restituita che hanno causato l'errore per me. Quindi, ho applicato alcune delle risposte fornite qui per rilevare l'ID errato, quindi rimuovere gli spazi extra dalla stringa. Ecco il codice che ha funzionato per me per risolvere finalmente il 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("/");
      }
    });
});

Questo ha funzionato per me e presumo che se altri elementi iniziano ad apparire nella stringa di ritorno, possono essere rimossi in modo simile.

Spero che aiuti.

Ho risolto questo problema modificando l'ordine dei percorsi.

Ho avuto problemi con questo e fissato fare mongoose.ObjectId(id)senzaTypes