TypeError: undefined nie jest funkcją w nodejs

Question

To jest mój model users.js.

var mongoose = require('mongoose') 
    , crypto = require('crypto') 
    , mongoTypes = require('mongoose-types'); 

mongoTypes.loadTypes(mongoose, 'email'); 
mongoose.connect('mongodb://localhost/popbroker'); 

function hash1 (msg, key) { 
    return crypto.createHmac('sha256', key).update(msg).digest('hex'); 
}; 

function required(val) { return val && val.length; } 

var Schema = mongoose.Schema 
    , ObjectId = Schema.ObjectId; 

var UserSchema = new Schema({ 
    username: { 
     type: String, 
     validate: [required,"Username is required"], 
     index: {unique: true} 
    }, 
    email: { 
     type: mongoose.SchemaTypes.Email, 
     validate: [required, 'Email required'], 
     index: { unique: true } 
    }, 
    password: { 
     type: String, 
     validate: [required, 'Password required'], 
    }, 
    socialauth:{ 
     type:String, 

    createdAt: { 
     type: Date, 
     'default': Date.now 
    } 
}); 


var UserApiSchema = new Schema({ 
    user :ObjectId, 
    apiKey: { 
     type: String, 
     validate: [required, 'Senha é obrigatório'], 
    }, 
    createdAt: { 
     type: Date, 
     'default': Date.now 
    } 
}); 


UserSchema.path('email').validate(function (v, fn) { 
    User.count({email: v}, function (err, val) { 
     if (err) fn(false); 
     fn(val==0); 
    }); 
}, 'Email exists!'); 

UserSchema.path('username').validate(function(v,fn){ 
    User.count({username:v},function(err,val){ 
    if(err) fn(false); 
    fn(val==0); 
    }); 
},'Username exists'); 

UserApiSchema.path('apiKey').validate(function(v,fn){ 
    UserApi.count({apiKey:v},function(err,val){ 
    if(err) fn(false); 
    fn(val == 0); 
    }); 
}, 'Api Key wrong'); 


UserSchema.statics.authenticate = function (email, password, fn) { 
    this.findOne({email: email}, function (err, user) { 
     if (!user) return fn(new Error('cannot find user')); 
     if (user.password == hash1(password, conf.secret)) return fn(null, user); 
     // Otherwise password is invalid 
     fn(new Error('invalid password')); 
    }) 
;}; 

UserApiSchema.statics.createApi = function(user,fn){ 
    var instance = new UserApi(); 
    instance.user = user; 
    instance.apiKey = "asdasdacas121213dasasd"; 
    console.log("username is " + user.username); 
    instance.save(function(err){ 
    fn(err,instance); 

    }); 
}; 


UserSchema.statics.getUser = function(userid){ 
    var user = mongoose.model('User', UserSchema); 
    var query = user.findOne({'_id':userid}) 
    query.exec(function (err, user) { 
    if (err) return handleError(err); 
    console.log(user.username); 
    return user; 
}); 
} 


UserApiSchema.statics.getUser = function(apiKey,fn){ 
    var usAp = UserApiSchema 
    var userApi = mongoose.model('UserApi', UserApiSchema); 
    var user = mongoose.model('User', UserSchema); 
    var query = userApi.findOne({ 'apiKey': apiKey }); 


    query.exec(function (err, userApi) { 
    if (err) return handleError(err); 
    console.log(userApi.user); 
    user = user.getUser(userApi.user); 
    fn(err, userApi);;// Space Ghost is a talk show host. 
}); 
}; 

UserSchema.statics.newUser = function (email, password,username, fn) { 
    var instance = new User(); 
    var apiInstance = new UserApi(); 
    instance.email = email; 
    instance.password = require('crypto').createHash('sha256').update(password).update('salt').digest('hex'); 
    instance.username = username; 

    instance.save(function (err) { 
     fn(err, instance); 
    }); 
}; 

UserSchema.statics.resetPassword = function(userId, callback) { 
    var newPassword = ''; 
    newPassword = newPassword.randomString(6); 
    var cripto = password; 
    var data = {} 
     data.password = crypto; 

    this.update({_id: userId} 
     , {$set: data} 
     , {multi:false,safe:true} 
     , function(error, docs) { 
      if (error) { 
       callback(error); 
      } 
      else { 
       callback(null, newPassword); 
      } 
     }); 
} 


var LinkSchema = new Schema({ 

    user: ObjectId, 

    text: { 
     type: String, 
     validate: [required,"Text is required"], 
     index: {unique: true} 
    }, 
    body: { 
     type: String, 
     validate: [required, 'Body is required'], 
     index: { unique: true } 
    }, 
    createdAt: { 
     type: Date, 
     'default': Date.now 
    } 
}) 

/* 
Exporting findByid function to return back a link based on an id. 
*/ 

LinkSchema.statics.newLink = function (text, body,user, fn) { 
    var instance = new Link(); 
    instance.text = text; 
    instance.body =body; 
    instance.user = user; 

    instance.save(function (err) { 
     fn(err, instance); 
    }); 
}; 


/* 
Export findAll function to return back all the links. 
*/ 

exports.findAll = function(req,res){ 
    console.log("Retrieving all the links"); 
    db.collection('links',function(err,collection){ 
    collecction.find().toArray(function(err,items){ 
     res.send(items); 

    }); 
    }); 
}; 



Link = mongoose.model('Link', LinkSchema); 

exports.Link = Link; 


User = mongoose.model('User', UserSchema); 
UserApi = mongoose.model('UserApi',UserApiSchema); 
exports.UserApi = UserApi; 
exports.User = User; 

Ponieważ jestem nowy dla nodejs, bardzo trudno jest zrozumieć, co oznacza ten błąd i dlaczego tak się dzieje. Zatem, co oznacza błąd i jak się go pozbyć?

Edytuj: To jest moje nowe połączenie z użytkownikiem.

app.post(
     '/signup/', 
     function(req, res) { 
      {console.log(req.body.username); 
       User.newUser(

        req.body.email, req.body.password,req.body.username,req.body.apiKey,"pocket", 
        function (err, user) { 
         if ((user)&&(!err)) { 
          console.log(user.username) 

          UserApi.createApi(
            user,function(err,userapi){ 
             if((!err)){ 
              console.log("Api created"); 
              res.send("APi created"); 

             } 
             else{ 
              if(err.errors.apiKey){ 
               res.send(err); 
              } 
             } 


            }); 
          req.session.regenerate(function(){ 
           req.session.user = user._id; 
           //res.send("Success here!"); 

          }); 
         } else { 
          if (err.errors.email) { 
           res.send(err) 
           console.log(req.body.password); 
           console.log(req.body.email); 
           console.log(req.body); 
          }       
          if (err.errors.username) { 
           res.send(err) 
           console.log(req.body.password); 
           console.log(req.body.email); 
           console.log(req.body); 
          } 
         } 
        }); 


      } 
     }); 

Answer 1

Dzięki swojej zmiany, kwestia, że ​​jesteś przechodzącej więcej argumentów niż newUser spodziewa. To skutkuje fn jest ustawiona wartość req.body.apiKey, który jest najwyraźniej undefined:

UserSchema.statics.newUser = function (email, password, username, fn) { 
    // ... 
}); 

User.newUser(    // set to... 
    req.body.email,   // => email 
    req.body.password,  // => password 
    req.body.username,  // => username 
    req.body.apiKey,  // => fn 
    "pocket",    // => (unnamed), arguments[4] 
    function(err, user) { // => (unnamed), arguments[5] 
     // ... 
    } 
}); 

Będziesz albo chcesz zmienić funkcję nazwać dodatkowych argumentów lub usunąć je z rozmowy, jeśli nie są one rzeczywiście niezbędne (ponieważ tworzysz instancję UserApi zarówno wewnątrz newUser, jak i w ramach planowanego wywołania zwrotnego).

---

[pierwotnie]

Błąd oznacza, że ​​próbujesz zadzwonić wartość undefined.

Jedną z możliwości jest argument fn jak newUser spróbuje nazwać, czy to faktycznie function czy nie:

UserSchema.statics.newUser = function (email, password,username, fn) { 
    //... 
     fn(err, instance); 
    //... 
}); 

Ale wartość fn zależy od tego, jak nazwać newUser:

// fn = undefined 
User.newUser('email@domain', 'password', 'username'); 

// fn = function 
User.newUser('email@domain', 'pass', 'user', function (err, user) { }); 

Tak więc, albo chcesz przetestować, czy fn jest function przed próbą połączenia:

instance.save(function (err) { 
    if (typeof fn === 'function') { 
     fn(err, instance); 
    } 
}); 

Albo można przejść bezpośrednio do fnModel#save, który już obsługuje kiedy fn jest undefined:

instance.save(fn);