Mongoose Difficulty in displaying time stamps - node.js

I have been Recently Working on Mongoose To connect with the MongoDB with Node application.
I have Used Schemas to build the model and set the timestamps to true.
But When i try to run the node application it displays a very long message and the time stamps are empty in the terminal but displays when copied and pasted in text editor.
I want the output to be short to only display the documents available in my collection.
Here is My code
index.js file
const mongoose = require('mongoose');
const Dishes = require('./models/dishes')
const url = 'mongodb://localhost:27017/conFusion';
const connect = mongoose.connect(url);
connect.then((db) => {
console.log('Connected correctly to server');
Dishes.create({
name: 'Uthapizzas',
description: 'Test'
})
.then((dish) => {
console.log(dish);
return Dishes.findByIdAndUpdate(dish._id,{
$set: { description: 'Updated Test'}
},{
new: true//return the updated dish
}).exec();
})
.then((dish) => {
console.log(dish);
dish.comments.push({
rating: 5,
comment: 'I\'m getting a sinking feeling!',
author: 'Leonardo di Carpaccio'
});
return dish.save();
})
.then((dish) => {
console.log(dish);
return Dishes.remove({});
})
.then(() => {
return mongoose.connection.close();
})
.catch((err) => {
console.log(err);
});
dishes.js file
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const commentSchema = new Schema({
rating: {
type: Number,
min: 1,
max: 5,
required: true
},
comment: {
type: String,
required: true
},
author:{
type: String,
required: true
}
}, {
timestamps: true
});
const dishSchema = new Schema({
name: {
type: String,
required: true,
unique: true
},
description: {
type: String,
required: true
},
comments:[commentSchema]
},
{
timestamps: true
}
);
var Dishes = mongoose.model('Dish', dishSchema);
module.exports = Dishes;
Here is My output
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: undefined,
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: true,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array],
map: [Function (anonymous)]
},
pathsToScopes: {},
session: null,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': {}
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Test',
comments: CoreMongooseArray(0) [
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.266Z,
__v: 0
}
}
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: {},
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: undefined,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array]
},
pathsToScopes: {},
session: undefined,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': { skipId: true, isNew: false, skipDefaults: [Object] }
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Updated Test',
comments: CoreMongooseArray(0) [
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.287Z,
__v: 0
},
'$init': true
}
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: {},
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: false,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array],
map: [Function (anonymous)]
},
pathsToScopes: { comments: [Circular *1] },
session: undefined,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': { skipId: true, isNew: false, skipDefaults: [Object] }
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Updated Test',
comments: CoreMongooseArray(1) [
[EmbeddedDocument],
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.308Z,
__v: 1
},
'$init': true
}
Can You Please Help me in resolving this issue.
Why i am getting this much lines of output and why my time stamps are not displaying in the output(They are Displaying when copied) and the output looks very clumsy.
I only need the output which document i have inserted into the database and need the time stamps.
I am not able to access the time stamps also.
I am using mongo v5
Thank you in advance!!

You should log your plaing javascript object, not the document. In order to do this, you should call console.log(dish.toJSON()).

Related

find and findone giving me model contents instead of records

I am trying to fetch one record from Mongo using the following code.
I have created a schema in another file
const mongoose = require('mongoose');
const appData = require('../../../core/utilities/appData.js');
const Schema = mongoose.Schema;
const clientListingSchema = new Schema({
...});
const clientListingsModel = mongoose.model('clientlistings', clientListingSchema);
module.exports = clientListingsModel;
And have imported the above in another file
const clientListingModel = require('./../models/clientListing');
clientListingModel.findOne({'_id': client_listings_id}).then((client_listing) => {
console.log(client_listing);
});
But I am getting something like this
model {
'$__': InternalCache {
strictMode: true,
selected: {},
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: undefined,
version: undefined,
getters: {},
_id: 5dd4de69c7d3b8585464dadd,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array]
},
pathsToScopes: {},
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: 0
},
'$options': true
},
isNew: false,
errors: undefined,
_doc: {
number: 3,
hub_coordinates: [
0,
0,
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
_path: 'hub_coordinates',
isMongooseArray: true,
validators: [],
_schema: [SchemaArray]
],
...
},
'$init': true
}
Need help figuring out how I can get only the record and not model contents.
Any help figuring this out is appreciated.
You can use lean
By default, Mongoose queries return an instance of the Mongoose Document class. Documents are much heavier than vanilla JavaScript objects, because they have a lot of internal state for change tracking.
Enabling the lean option tells Mongoose to skip instantiating a full Mongoose document and just give you the POJO.
change your code as below
clientListingModel.findOne({'_id': client_listings_id}).lean().then((client_listing) => {}
Hope it will help you.
Try for the following:
JSON.parse(JSON.stringify(client_listing))

NodeJs mssql connection returning undefined from .Request()

I'm having trouble getting a working connection via nmp's mssql package.
Here's a quick look at my code:
var sql = require('mssql');
var sqlConfig = {
user: 'NodeUser',
password: 'test',
server: '10.211.55.3',
database: 'NodeJs'
}
sql.connect(sqlConfig, function(err){
if(err != null)
console.log(err);
console.log(sql);
});
Which seems to connect fine, but when I try to use it (in a route class):
var sql = require('mssql');
bookRouter.route('/')
.get(function(req, res){
var req = sql.Request();
req.query('select * from books', function(err, recordset){
console.log(recordset);
});
res.render('BookListView', {
title: 'Hello from Books',
nav: nav,
books: books
});
});
I get "TypeError: Cannot read property 'query' of undefined" on the req.query line. It seems like an issue with the connection? The only useful thing I could think to pull was the result of the "console.log(sql);" line above:
{ connect: [Function],
close: [Function],
on: [Function],
Connection:
{ [Function: Connection]
EventEmitter:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: false,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
usingDomains: false,
defaultMaxListeners: 10,
init: [Function],
listenerCount: [Function],
__super__:
EventEmitter {
domain: undefined,
_events: undefined,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
once: [Function: once],
removeListener: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
listenerCount: [Function: listenerCount] } },
Transaction:
{ [Function: Transaction]
EventEmitter:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: false,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
usingDomains: false,
defaultMaxListeners: 10,
init: [Function],
listenerCount: [Function],
__super__:
EventEmitter {
domain: undefined,
_events: undefined,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
once: [Function: once],
removeListener: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
listenerCount: [Function: listenerCount] } },
Request:
{ [Function: Request]
EventEmitter:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: false,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
usingDomains: false,
defaultMaxListeners: 10,
init: [Function],
listenerCount: [Function],
__super__:
EventEmitter {
domain: undefined,
_events: undefined,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
once: [Function: once],
removeListener: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
listenerCount: [Function: listenerCount] } },
Table: { [Function: Table] fromRecordset: [Function] },
PreparedStatement:
{ [Function: PreparedStatement]
EventEmitter:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: false,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
usingDomains: false,
defaultMaxListeners: 10,
init: [Function],
listenerCount: [Function],
__super__:
EventEmitter {
domain: undefined,
_events: undefined,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
once: [Function: once],
removeListener: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
listenerCount: [Function: listenerCount] } },
ConnectionError:
{ [Function: ConnectionError]
captureStackTrace: [Function: captureStackTrace],
stackTraceLimit: 10,
prepareStackTrace: undefined,
__super__: [Error] },
TransactionError:
{ [Function: TransactionError]
captureStackTrace: [Function: captureStackTrace],
stackTraceLimit: 10,
prepareStackTrace: undefined,
__super__: [Error] },
RequestError:
{ [Function: RequestError]
captureStackTrace: [Function: captureStackTrace],
stackTraceLimit: 10,
prepareStackTrace: undefined,
__super__: [Error] },
PreparedStatementError:
{ [Function: PreparedStatementError]
captureStackTrace: [Function: captureStackTrace],
stackTraceLimit: 10,
prepareStackTrace: undefined,
__super__: [Error] },
ISOLATION_LEVEL:
{ READ_UNCOMMITTED: 1,
READ_COMMITTED: 2,
REPEATABLE_READ: 3,
SERIALIZABLE: 4,
SNAPSHOT: 5 },
DRIVERS: [ 'msnodesql', 'tedious', 'tds', 'msnodesqlv8' ],
TYPES:
{ VarChar: [sql.VarChar],
NVarChar: [sql.NVarChar],
Text: [sql.Text],
Int: [sql.Int],
BigInt: [sql.BigInt],
TinyInt: [sql.TinyInt],
SmallInt: [sql.SmallInt],
Bit: [sql.Bit],
Float: [sql.Float],
Numeric: [sql.Numeric],
Decimal: [sql.Decimal],
Real: [sql.Real],
Date: [sql.Date],
DateTime: [sql.DateTime],
DateTime2: [sql.DateTime2],
DateTimeOffset: [sql.DateTimeOffset],
SmallDateTime: [sql.SmallDateTime],
Time: [sql.Time],
UniqueIdentifier: [sql.UniqueIdentifier],
SmallMoney: [sql.SmallMoney],
Money: [sql.Money],
Binary: [sql.Binary],
VarBinary: [sql.VarBinary],
Image: [sql.Image],
Xml: [sql.Xml],
Char: [sql.Char],
NChar: [sql.NChar],
NText: [sql.NText],
TVP: [sql.TVP],
UDT: [sql.UDT],
Geography: [sql.Geography],
Geometry: [sql.Geometry],
Variant: [sql.Variant] },
MAX: 65535,
map:
[ { js: [Function: String], sql: [sql.NVarChar] },
{ js: [Function: Number], sql: [sql.Int] },
{ js: [Function: Boolean], sql: [sql.Bit] },
{ js: [Function: Date], sql: [sql.DateTime] },
{ js: [Object], sql: [sql.VarBinary] },
{ js: [Object], sql: [sql.TVP] },
register: [Function] ],
fix: true,
Promise: [Function: Promise],
VarChar: [sql.VarChar],
VARCHAR: [sql.VarChar],
NVarChar: [sql.NVarChar],
NVARCHAR: [sql.NVarChar],
Text: [sql.Text],
TEXT: [sql.Text],
Int: [sql.Int],
INT: [sql.Int],
BigInt: [sql.BigInt],
BIGINT: [sql.BigInt],
TinyInt: [sql.TinyInt],
TINYINT: [sql.TinyInt],
SmallInt: [sql.SmallInt],
SMALLINT: [sql.SmallInt],
Bit: [sql.Bit],
BIT: [sql.Bit],
Float: [sql.Float],
FLOAT: [sql.Float],
Numeric: [sql.Numeric],
NUMERIC: [sql.Numeric],
Decimal: [sql.Decimal],
DECIMAL: [sql.Decimal],
Real: [sql.Real],
REAL: [sql.Real],
Date: [sql.Date],
DATE: [sql.Date],
DateTime: [sql.DateTime],
DATETIME: [sql.DateTime],
DateTime2: [sql.DateTime2],
DATETIME2: [sql.DateTime2],
DateTimeOffset: [sql.DateTimeOffset],
DATETIMEOFFSET: [sql.DateTimeOffset],
SmallDateTime: [sql.SmallDateTime],
SMALLDATETIME: [sql.SmallDateTime],
Time: [sql.Time],
TIME: [sql.Time],
UniqueIdentifier: [sql.UniqueIdentifier],
UNIQUEIDENTIFIER: [sql.UniqueIdentifier],
SmallMoney: [sql.SmallMoney],
SMALLMONEY: [sql.SmallMoney],
Money: [sql.Money],
MONEY: [sql.Money],
Binary: [sql.Binary],
BINARY: [sql.Binary],
VarBinary: [sql.VarBinary],
VARBINARY: [sql.VarBinary],
Image: [sql.Image],
IMAGE: [sql.Image],
Xml: [sql.Xml],
XML: [sql.Xml],
Char: [sql.Char],
CHAR: [sql.Char],
NChar: [sql.NChar],
NCHAR: [sql.NChar],
NText: [sql.NText],
NTEXT: [sql.NText],
TVP: [sql.TVP],
UDT: [sql.UDT],
Geography: [sql.Geography],
GEOGRAPHY: [sql.Geography],
Geometry: [sql.Geometry],
GEOMETRY: [sql.Geometry],
Variant: [sql.Variant],
VARIANT: [sql.Variant],
pool: { max: 10, min: 0, idleTimeoutMillis: 30000 },
connection: { userName: '', password: '', server: '' },
init: [Function] }
I can't help but notice the lack of credentials here. Any thoughts? Thanks.
Looks like an issue of asynchronisity, try doing it on the request directly, like the mssql npm example:
var sql = require('mssql');
bookRouter.route('/')
.get(function(req, res){
sql.Request().query('select * from books')
.then(function(recordset){
console.log(recordset);
res.render('BookListView', {
title: 'Hello from Books',
nav: nav,
books: books
});
}).catch(function(err){
// some error handling
});
});

the nodejs and mongo db find

I use this code to connect to my mongo db localhost and find the "names" but i have a problem in consol.log:
url = require("url"),
emitter = require("events").EventEmitter,
assert = require("assert"),
mongo = require("mongodb"),
Cursor = mongo.Cursor;
var uristring = "mongodb://localhost:27017/test";
var mongoUrl = url.parse (uristring);
mongo.MongoClient.connect (uristring, function (err, db) {
var test = db.collection ("test")
console.log ("Success connecting to " + mongoUrl.protocol + "//" + mongoUrl.hostname + ".");
console.log (test.find({},{name:1,_id:0}));
db.close();
});
when i use db.test.find({},{name:1,_id:0}) in my terminal in mongo its returning { "name" : "pooya" }
but in nodjs code it return:
Success connecting to mongodb://localhost.
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'test',
serverConfig:
{ domain: null,
_events: {},
_maxListeners: 10,
_callBackStore: [Object],
_commandsStore: [Object],
auth: [Object],
_dbStore: [Object],
host: 'localhost',
port: 27017,
options: [Object],
internalMaster: true,
connected: true,
poolSize: 5,
disableDriverBSONSizeCheck: false,
_used: true,
replicasetInstance: null,
emitOpen: false,
ssl: false,
sslValidate: false,
sslCA: null,
sslCert: undefined,
sslKey: undefined,
sslPass: undefined,
serverCapabilities: [Object],
name: 'localhost:27017',
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connected',
_state: [Object],
recordQueryStats: false,
socketTimeoutMS: [Getter/Setter],
_readPreference: [Object],
db: [Circular],
dbInstances: [Object],
connectionPool: [Object],
isMasterDoc: [Object] },
options:
{ read_preference_tags: null,
read_preference: 'primary',
url: 'mongodb://localhost:27017/test',
native_parser: true,
readPreference: [Object],
safe: false,
w: 1 },
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: true,
bsonLib:
{ BSON: [Object],
Long: [Object],
ObjectID: [Object],
DBRef: [Function: DBRef],
Code: [Function: Code],
Timestamp: [Object],
Binary: [Object],
Double: [Function: Double],
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
Symbol: [Function: Symbol] },
bson: { promoteLongs: true },
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
_state: 'connected',
pkFactory:
{ [Function: ObjectID]
index: 2954887,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString],
isValid: [Function: isValid] },
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: { error: [Function], log: [Function], debug: [Function] },
tag: 1416152062206,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined } },
collection:
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'test',
serverConfig: [Object],
options: [Object],
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: true,
bsonLib: [Object],
bson: [Object],
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connected',
pkFactory: [Object],
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: [Object],
tag: 1416152062206,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: [Object] },
collectionName: 'test',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined },
pkFactory:
{ [Function: ObjectID]
index: 2954887,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString],
isValid: [Function: isValid] },
serverCapabilities: undefined },
selector: {},
fields: { name: 1, _id: 0 },
skipValue: 0,
limitValue: 0,
sortValue: undefined,
hint: null,
explainValue: undefined,
snapshot: undefined,
timeout: true,
tailable: undefined,
awaitdata: undefined,
oplogReplay: undefined,
numberOfRetries: 5,
currentNumberOfRetries: 5,
batchSizeValue: 0,
raw: false,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined },
returnKey: undefined,
maxScan: undefined,
min: undefined,
max: undefined,
showDiskLoc: undefined,
comment: undefined,
tailableRetryInterval: 100,
exhaust: false,
partial: false,
slaveOk: false,
maxTimeMSValue: undefined,
connection: undefined,
totalNumberOfRecords: 0,
items: [],
cursorId: { _bsontype: 'Long', low_: 0, high_: 0 },
dbName: undefined,
state: 0,
queryRun: false,
getMoreTimer: false,
collectionName: 'test.test' }
why its happening?how to solve it?
Welcome to StackOverflow.
You are using the API wrongly. The MongoDB driver returns the query results asynchronously, via callback, not synchronously like in most languages you probably met so far, if you are new to node.js.
So, basically you are doing this
var results = test.find({},{name:1,_id:0})
console.log (results);
But what you really want to do is:
test.find({name:1,_id:0}, new function(error, results)
{
if(error! = null) console.log(error);
else //do whatever you want with the results
});
Keep in mind that the code after test.find() will keep running independently of the query and its results. The results processing will be called when the query is finished.
Btw. I also think parameters passed to your find() method are somehow wrong. The query should be the first parameter, and in your example it's second, if I'm not mistaken. The method looks like this: find(query[, options], callback).
You can find the documentation of the MongoDB driver here, including the find method.
You should more or less do the same with the find() method as you did with the connect() method in which callback you are writing the query.
If you are not comfortable with the notion of asynchronous, event driven or non-blocking programming please consider reading these links:
http://book.mixu.net/node/ch7.html
http://justinklemm.com/node-js-async-tutorial/
EDIT:
Sorry, I must edit myself. The callback has two parameters, the FIRST one is the error, the SECOND are the results. Haven't used this for a while.

Trouble getting a response from cursor.toArray() in Mongo/Node

node 0.10.24 + mongo node driver 1.3.23 on 32 bit linux
My callback here is never getting executed.
console.log(record_collection);
record_collection.find({}, function (error, cursor) {
console.log("record_collection.find() returned");
if (error) {
console.log(error);
callback(error);
}
else {
console.log("calling toArray with cursor");
cursor.toArray(function(error, docs){
console.log("cursor.toArray() returned");
if (error) {
console.log(error);
callback(error);
}
else {
callback(null, docs);
}
});
}
});
The output from this section goes like this:
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'dbname',
serverConfig:
{ domain: null,
_events: {},
_maxListeners: 10,
_callBackStore: [Object],
_commandsStore: [Object],
auth: [Object],
_dbStore: [Object],
host: 'localhost',
port: 27017,
options: [Object],
internalMaster: false,
connected: false,
poolSize: 5,
disableDriverBSONSizeCheck: false,
_used: true,
replicasetInstance: null,
emitOpen: true,
ssl: false,
sslValidate: false,
sslCA: null,
sslCert: undefined,
sslKey: undefined,
sslPass: undefined,
serverCapabilities: null,
name: 'localhost:27017',
_readPreference: null,
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connecting',
_state: [Object],
recordQueryStats: false,
socketTimeoutMS: [Getter/Setter],
db: [Circular],
dbInstances: [Object],
connectionPool: [Object] },
options: {},
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: undefined,
bsonLib:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson: { promoteLongs: true },
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
_state: 'connecting',
pkFactory:
{ [Function: ObjectID]
index: 14382708,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: { error: [Function], log: [Function], debug: [Function] },
tag: 1390462362041,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: undefined },
collectionName: 'gis_stops',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: 'primary',
pkFactory:
{ [Function: ObjectID]
index: 14382708,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
serverCapabilities: undefined }
record_collection.find() returned
calling toArray with cursor
It looks like the first console.log() of the collection doesn't finish. But the other traces appear. Why isn't the callback being executed? Why don't I see "cursor.toArray() returned"?
This stopped working when I moved to a new server. The old server was running node 0.10.13 and mongodb 1.2.13.
From the record_collection trace:
db.serverConfig.connected = false;
The database was not connected.

Can't return a string properly with mongoskin

So I have this script:
var db = require('mongoskin').db('localhost:27017/titles', {safe:true});
var titles = db.collection('titles');
title = titles.findOne(function(err, result){
if (err) throw err;
return result.title;
});
console.log(title)
And this BSON object in the collection:
{"title": "Hello World", "postNumber": 0, "_id": ObjectId("509eeffbf8f11e8813000001")}
My goal is got get the string "Hello World" to output to the console, but instead I get this:
{ emitter: { _events: { open: [Object] }, _maxListeners: 50 },
state: 1,
options: undefined,
skinDb:
{ emitter: { _events: [Object], _maxListeners: 100 },
state: 1,
_dbconn:
{ databaseName: 'titles',
serverConfig: [Object],
options: [Object],
_applicationClosed: false,
native_parser: true,
bsonLib: [Object],
bson: {},
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connecting',
pkFactory: [Object],
forceServerObjectId: false,
safe: true,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
_callBackStore: [Object],
logger: [Object],
slaveOk: false,
tag: 1352682584657,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
reaperEnabled: false,
_lastReaperTimestamp: 1352682584657,
retryMiliSeconds: 1000,
numberOfRetries: 60,
reaperInterval: 10000,
reaperTimeout: 30000,
readPreference: undefined },
db: null,
username: '',
password: undefined,
admin: { emitter: {}, state: 0, skinDb: [Circular], admin: null },
_collections: { titles: [Circular] },
bson_serializer:
{ BSON: [Object],
Long: [Object],
ObjectID: [Object],
DBRef: [Function: DBRef],
Code: [Function: Code],
Timestamp: [Object],
Binary: [Object],
Double: [Function: Double],
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
Symbol: [Function: Symbol] },
ObjectID:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] } },
ObjectID:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
collectionName: 'titles',
collection: null,
internalHint: null,
hint: [Getter/Setter] }
It works just fine when I put the console.log() inside the function, I just can't return the string for some reason.
Solved:
read = function(callback){
titles.findOne(function(err, result){
if (err) throw err;
callback(result.title);
});
};
read(function(title){
console.log(title);
});
you need to understand javascript callback.
1 - findOne will return a db object not the result of your string. I never read the mongoskin doco but I think it will be a db collection or some sort which is what you see in the console.log print out.
2 - in the callback your do return result.title; will never return the title back as you would expect. so that is why I suggest to do some reading on how callback work.
The correct way to print the title will be putting the console.log inside the callback function as you mention.

Resources