Hi There: I'm having a difficult time online finding out how to perform a simple database connection, schema creation, and basic CRUD using mongoose with node.js. Right now I have the following code but am getting the error:
"TypeError: object is not a function
at Schema.CALL_NON_FUNCTION_AS_CONSTRUCTOR (native).."
// Launch express and server
var express = require('express');
var app = express.createServer();
//connect to DB
var mongoose = require('mongoose');
var db = mongoose.connect('mongodb://localhost/napkin_0.1');
// Define Model
var Schema = mongoose.Schema,
ObjectId = Schema.ObjectId;
User = new Schema({
'title': { type: String, index: true },
'data': String,
'tags': [String],
'user_id': ObjectId
});
//Define Collection
mongoose.model('Document', User);
var user = new User();
user.title = "TEST TITLE";
user.save();
//Launch Server
app.listen(3002);
You are trying to instantiate an instance of the Schema. I would change
User = new Schema({
To
UserSchema = new Schema({
and later on call
var User = mongoose.model('user', UserSchema);
and finally
var user = new User();
After your schema definition.
//Define Collection
mongoose.model('Document', User);
The above code is not for defining collection, it is to initialize the model object.
Change it as follows:
//Create Model Object
var UserModel = mongoose.model('user_model_name', User); // 2nd param -> User is a schema object
Then create the Document object out of model object.
As follows:
var user_doc = new UserModel();
Then you can use getters/setters and methods.
user_doc.title = 'your text for title';
user_doc.save();
Related
In my app.js I require my model like
var User = require('./models/user');
app.post('/user/add', function(req,res,next){
var newUser = new User();
newUser.add(req.body.name, function(response){
res.json(response);
})
});
and my model (user.js) look like this
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var userSchema = new Schema({
name: String
});
var User = module.exports = mongoose.model('user', userSchema);
module.exports.add = function(name,callback){
User.save({name:name}).exec(callback);
}
But I got error of newUser.add is not a function?
If you want to add instance methods to a mongoose Model you should use instance methods syntax:
var mongoose = require('mongoose');
var UserSchema = new mongoose.Schema({
name: String
});
// Instance methods
UserSchema.methods.add = function(name, callback){
this.name = name;
return this.save(callback);
}
module.exports = mongoose.model('User', UserSchema);
Methods can be added with methods keyword like this
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var userSchema = new Schema({
name: String
});
userSchema.methods.add = function(name,callback){
User.save({name:name}).exec(callback); // not checking logic
}
var User = module.exports = mongoose.model('user', userSchema);
You can do it as follows:
var mongoose = require('mongoose');
var Schema = Mongoose.Schema;
//schema is declared here
var userSchema = new Schema({
name: String
});
var user = Mongoose.model('User', UserSchema);
//here we are assigning new data to user collection
//this record will not be saved here
//it will only check the schema is matching or not
//if record is matching to schema then it will assign '_id' to that record
var userRec = new user({"name":"Jessie Emerson"});
userRec.save(function(error, userDoc) {
//this is the callback function
});
If you need anymore clarifications then please comment on this answer. :-)
I have an application with two modules (Book and User). The book model looks like this:
var mongoose = require('mongoose'),
Schema = mongoose.Schema;
var BookModel = new Schema({
name: String,
author: String,
description: String,
_user: {type: Schema.Types.ObjectId, ref: 'User'}
});
module.exports = mongoose.model('Book', bookModel);
And the user model:
var mongoose = require('mongoose'),
bcrypt = require('bcryptjs'),
Schema = mongoose.Schema;
var userModel = new Schema({
name: String,
username: String,
password: String,
});
module.exports = mongoose.model('User', userModel);
I want to do a unit test in the POST method (inserting a book in the DB) with the condition of not allowing empty name. This is what I have in the POST method:
var post = function (req, res) {
var bookNew = new book(req.body);
// get paylod from the user's token
var payload = tokenManager.getPayload(req.headers);
if (req.body._user)
delete req.body._user;
if (!req.body.name) {
res.status(400);
res.send("Name is required");
} else if (payload == null || payload == undefined) {
res.status(400);
res.send("Token error");
} else {
// store the user id
bookNew.set('_user', payload.id);
bookNew.save();
res.status(201);
res.send("Book saved");
}
};
As you can see, I get the payload from the token (created when the user is logged in). I do this because the payload contains the user id and, then, I insert it in _user (property in book model).
The problem is that if I do a unit test in order to verify if the book’s property (name) is filled, I don’t have a user to retrieve the payload. Therefore, the payload will be undefined and the book unit test will not be successful in any case. Do you have any suggestion on what I should do? It looks like I have to create a user in order to test all book modules… but I am not sure if that is the most suitable solution.
I'm making a node application. Users can have favorite Listings of rooms ( just like wish list). I'm trying to add listings ids to user favorite listings but that always gives undefined. if i do "console.log(users.favoriteListings);" the output comes to be undefined. Any help please.
listingModel.js
var mongoose = require("mongoose");
var Schema = mongoose.Schema;//creating schema
var ListingSchema = new Schema({
location: {//ROOM LOCATION
type: [Number], // [<longitude>, <latitude>]
index: '2d' // create the geospatial index
},
}
);
var Listing = mongoose.model('Listing', ListingSchema);
module.exports = Listing;
userModel.js
var mongoose = require("mongoose");
var Schema = mongoose.Schema;//creating schema
var Listing=require('../listing/listingModel');
var UserSchema = new Schema({
favoriteListings : [{ type: Schema.Types.ObjectId, ref: 'Listing' }],
}
);
var User = mongoose.model('User', UserSchema);
module.exports = User;
userController.js
addFavListing:function(req,res){
//READ TOKEN AND FIND USER ID, IF USER HAS REACHED THIS POINT, THIS MEANS THAT TOKEN ALREADY
//HAS BEEN VERIFIED
var token = req.body.token || req.query.token || req.headers['x-access-token'];
var decoded=jwt.verify(token, app.get('superSecret'));
var id=decoded._doc._id;console.log(id);
User.find({_id:id}).populate('favoriteListings').exec(function(err,users) {
if (err){ return handleError(err);}
console.log(users.favoriteListings);
});
You got an array of users from mongoose.
This array has no favoriteListings property.
But each user in the array must have his favoriteListings.
In your userController, try to replace the console.log by this one:
console.log(users.forEach(function(user) {
console.log(user.favoriteListings);
}));
I am trying to join two collections and being able to get the combined data. To do so using Mongoose, i am supposed to use the populate syntax to achieve that. I am receiving error that the Schema Schema hasn't been registered for 'User_Fb'. From my code, I have exported the models and required in my server.js but the error is still appearing. What have I done wrong?
feed_post.model.js
var mongoose = require('mongoose');
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var User_fb = require('../models/fb_db.model');
var Schema = mongoose.Schema;
var feed_postSchema = new Schema({
user_id: { type: Schema.Types.ObjectId, ref: 'User_Fb' },
content: String,
location: String,
image: [{ type : String }]
});
var Feed_Post = conn_new_app.model('Feed_Post', feed_postSchema);
module.exports = Feed_Post;
fb_db.model.js
var mongoose = require('mongoose');
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('../models/feed_post.model');
var user_fb = new mongoose.Schema({
name: String,
location: String,
fb_id: Number
});
var User_Fb = conn_new_app.model('User_Fb', user_fb);
module.exports = User_Fb;
server.js
var express = require('express'),
mongoose = require('mongoose'),
User = require('./app/models/user.model'),
Post = require('./app/models/post.model'),
Maptest = require('./app/models/maptest.model'),
Feed_Post = require('./app/models/feed_post.model'),
User_Fb = require('./app/models/fb_db.model'),
app = express();
app.get('/testget', function(req,res){
Feed_Post.findOne().populate('user_id').exec(function(err, c) {
if (err) { return console.log(err); }
console.log(c.fk_user.userName);
});
});
UPDATED from Pier-Luc Gendreau Answer's
fb_db.model.js
module.exports = function (connection) {
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var user_fb = new mongoose.Schema({
name: String,
location: String,
fb_id: Number
});
return connection.model('User_FB', user_fb);;
}
feed_post.model.js
module.exports = function (connection) {
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var feed_postSchema = new Schema({
user_id: { type: Schema.Types.ObjectId, ref: 'User_Fb' },
content: String,
location: String,
image: [{ type : String }]
});
return connection.model('Feed_Post', feed_postSchema);;
}
server.js
var express = require('express'),
app = express(),
mongoose = require('mongoose'),
conn_new_app = mongoose.createConnection('mongodb://localhost/new_app'),
User_Fb = require('./app/models/fb_db.model')(conn_new_app),
Feed_Post = require('./app/models/feed_post.model')(conn_new_app);
app.get('/testget', function(req,res){
Feed_Post.find().populate('user_id').exec(function(err, res) {
if (err) { return console.log(err); }
console.log(res);
});
});
This is all I had to do Customer.findOne({}).populate({ path: 'created_by', model: User }) instead of this Category.findOne({}).populate({'author'})
IF YOU (really) USE MULTIPLE mongoDB CONNECTIONS
I do realise that this is not the case for the OP, but if you genuinely use multiple connections you MUST provide the model when using .populate(), as mongoose will only "find" models on the same connection.
ie where:
var db1 = mongoose.createConnection('mongodb://localhost:27017/gh3639');
var db2 = mongoose.createConnection('mongodb://localhost:27017/gh3639_2');
var userSchema = mongoose.Schema({
"name": String,
"email": String
});
var customerSchema = mongoose.Schema({
"name" : { type: String },
"email" : [ String ],
"created_by" : { type: mongoose.Schema.Types.ObjectId, ref: 'users' },
});
var User = db1.model('users', userSchema);
var Customer = db2.model('customers', customerSchema);
Correct:
Customer.findOne({}).populate('created_by', 'name email', User)
or
Customer.findOne({}).populate({ path: 'created_by', model: User })
Incorrect (produces "schema hasn't been registered for model" error):
Customer.findOne({}).populate('created_by');
The problem is that you are creating a new connection in each and every model, so you end up with a bunch of different connection objects. Even though they are pointing to the same database, mongoose models don't know about other connections. You should instead create the connection object in your main app and then pass it around.
server.js
var express = require('express');
var mongoose = require('mongoose');
var app = express();
var conn_new_app = mongoose.createConnection('mongodb://localhost/new_app');
var Feed_Post = require('./app/models/feed_post.model')(conn_new_app);
app.get('/testget', function(req,res){
Feed_Post.findOne().populate('user_id').exec(function(err, c) {
if (err) { return console.log(err); }
console.log(c.fk_user.userName);
});
});
Then modify your models so they are actually a function:
feed_post.model.js
module.exports = function (connection) {
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var feed_postSchema = new Schema({
user_id: { type: Schema.Types.ObjectId, ref: 'User_Fb' },
content: String,
location: String,
image: [{ type : String }]
});
return connection.model('Feed_Post', feed_postSchema);;
}
Also, like Adrian mentions, you can use mongoose as a singleton. However, I do recommend using createConnection as you did because if you ever need a second connection, you won't have to refactor the connection code to your first database.
It looks like you are creating a different database connection for each model, which isolates the models from each other. Mongoose must assume this isolation, because they could exist on different databases or even database servers.
Try connecting once, and just calling mongoose.model() instead of connection.model() when defining your models. Mongoose is a singleton by default.
In my case, this issue because I haven't included the ref model into the application.
You can get the field you want by using select
Example to get the email of the customer:
Customer.findOne({}).populate({ path: 'created_by', model: User, select: 'email' })
More Details in mongoose documentation
the issue i'm having is that mongoose isn't letting me instantiate an object of a schema type, inside a 'pre' method, of a different schema.
I've got 2 schemas - 'User' and 'Tickit'.
User.js
var mongoose = require('mongoose');
var bcrypt = require('bcrypt-nodejs');
var Schema = mongoose.Schema;
var Tickit = require('../models/Tickit');
var userSchema = new Schema({
email : String,
password : String,
tickits : [Tickit.tickitSchema]
});
userSchema.methods.generateHash = function(password) {
return bcrypt.hashSync(password, bcrypt.genSaltSync(8), null);
};
userSchema.methods.validPassword = function(password) {
return bcrypt.compareSync(password, this.password);
};
module.exports = mongoose.model('User', userSchema);
and Tickit.js
var mongoose = require('mongoose');
var User = require('../models/User');
var Schema = mongoose.Schema;
var tickitSchema = new Schema({
title: String,
description: String,
author : { type: Schema.Types.ObjectId, ref: 'User' },
comments: [{body:"string", by: mongoose.Schema.Types.ObjectId}]
});
tickitSchema.pre('save', function(next){
var user = new User();
user.tickits.push ({id:this._id});
user.save(function(err){
if(err)
res.send(err)
.populate('tickits')
.exec(function(err, blah){
if(err) res.send(err);
})
res.json(blah);
})
next();
})
module.exports = mongoose.model('Tickit', tickitSchema);
What i'm trying to do with the pre method in Tickit is populate the 'Tickits' array in the User schema with the id of that Tickit every time a Tickit is created.
However in my app when I do create a tickit, the app crashes and I get this error
var user = new User();
^
TypeError: object is not a function
Try to define user inside your function:
tickitSchema.pre('save', function(next){
var User = require('../models/User');
// Code
});