Che cosa sto sbagliando in questa convalida unica pre-salvataggio Mongoose?

Question

Sto provando a creare un modello Utente, che ha un nome utente univoco. Ecco il codice per esso:

var mongoose = require("mongoose"); 

var Schema = mongoose.Schema; 

var UserSchema = new Schema({ 
    username: String, 
    password: String, 
}); 

UserSchema.virtual("password_confirmation").get(function() { 
    return this.pw_conf; 
}).set(function(value) { 
    this.pw_conf = value; 
}); 

UserSchema.path("username").required(true); 
UserSchema.path("password").required(true); 

UserSchema.pre("save",function(next, done) { 
    var self = this; 
    mongoose.models["User"].findOne({username : self.username},function(err, user) { 
     if(user) { 
      self.invalidate("user","username must be unique"); 
     } 
     done(); 
    }); 
    next(); 
}); 

UserSchema.pre("save",function(next) { 
    if(this.pw_conf !== this.password) { 
     next(new Error("Must specify the password confirmation")); 
    } 
    else { 
     next(); 
    } 
}); 

module.exports = mongoose.model("User",UserSchema); 

ero anche testando per vedere se le opere unicità:

var User = require("./users"), 
    mongoose = require("mongoose"); 
var u = new User(); 

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

u.username = "me"; 
u.password = "password"; 
u.password_confirmation = "password"; 
u.save(function(err) { 
    if(err) { 
     console.log(err); 
    } 
    mongoose.disconnect(); 
}); 

Il problema è che non. Ogni volta che eseguo il codice, ottengo un nuovo oggetto creato. Sono consapevole che probabilmente ci sono altri modi per garantire l'unicità, ma mi piacerebbe farlo in questo modo. Non dovrei chiamare done dopo aver gestito il risultato del metodo findOne? Sto chiamando next sbagliato?

Answer 1

Per utilizzare parallel middleware (con next e done parametri), è necessario passare true come secondo parametro.

Oltre a ciò, ci sono due possibilità:

tuo self.invalidate chiamata deve essere riferimento a "username" invece di "user". Se questo non risolvere il problema, si può fallire le cose in modo esplicito passando un oggetto errore per done se si vuole interrompere l'operazione di salvataggio:

UserSchema.pre("save", true, function(next, done) { 
    var self = this; 
    mongoose.models["User"].findOne({username: self.username}, function(err, user) { 
     if(err) { 
      done(err); 
     } else if(user) { 
      self.invalidate("username", "username must be unique"); 
      done(new Error("username must be unique")); 
     } else { 
      done(); 
     } 
    }); 
    next(); 
}); 

Answer 2

http://mongoosejs.com/docs/api.html#schematype_SchemaType-unique è la strada da percorrere. Usa gli attuali indici MongoDb per assicurarsi che il tuo campo sia unico. Non è necessario il middleware .pre.

Divertiti!

Answer 3

Hai pensato di usare un validatore asincrono per catturare l'errore?

UserSchema.path('username').validate(function (value, done) { 
    User.count({ username: value }, function (error, count) { 
    // Return false if an error is thrown or count > 0 
    done(!(error || count)); 
    }); 
}, 'unique'); 

Answer 4

C'è un ottimo plugin per mangusta che è davvero facile da installare e utilizzare. La documentazione è eccellente e ha funzionato per me la prima volta.

ma c'è un problema con il ri-risparmio.

https://npmjs.org/package/mongoose-unique-validator