Save failing without error

Simple Unit Testing

Creating a model interpretor

Hello,

I'm writing an app that will translate a model definition for another
non-Node framework. I'm curious if I'm doing something wrong or if
there might be a bug in the latest build.

My app.js looks like so:

// Require global libraries
mongoose = require('mongoose');
config   = require('../../config.json');
require('./models.js');

// Require scoped libraries
var restify  = require('restify'),
	app   = restify.createServer(config.api);

// General API router
app.get(
	{ path: '/api/:parcel/:api_controller', version: '1.0.0' },
	function(request, response, next) {
		var controller = require(
			'../' + request.params.parcel + '/api/' +
request.params.api_controller
		);
		controller.index(request, response, next);
		response.end();
	}
);
app.listen(3000);

My model class looks like:

Model = function(parcel, name) {

	var model_name = name;
	var schema     = null;
	var parcel     = parcel;
	var model      = null;
	var db         = null;
	var fields     = null;

	this.init = function() {
		// Get the model definition from the proper folder
		var schema = require('../' + parcel + '/models/' + name + '.json');

		// Establish the database connection for this class
		db = mongoose.connect(
			'mongodb://' + config.database.DB_HOST + '/' +
config.database.DB_NAME
		);
		console.log(this.convert_fields(schema.fields));
		// Setup the mongoose model
		model = db.model(
			model_name,
			new mongoose.Schema(this.convert_fields(schema.fields))
		);
	}

        // Translates the old schema definition to Mongoose friendly
schema
	this.convert_fields = function(fields) {
		var converted_fields = {};
		for (var i in fields) {

			converted_fields[i] = {};
			converted_fields[i]['default'] = 'test';
			converted_fields[i]['required'] = true;

			// Convert the field types
			switch (fields[i].type) {
				case 'TEXT':
					converted_fields[i].type = mongoose.Schema.Types.String;
					break;
				case 'DATE':
					converted_fields[i].type = mongoose.Schema.Types.Date;
					break;
				case 'ENUM':
					converted_fields[i].enum = fields[i].value.replace(/'/g,
'').split(',');
					break;
				case 'INT':
					converted_fields[i].type = mongoose.Schema.Types.Number;
					break;
			}
		}
		return converted_fields;
	}
}

It's throwing errors when trying to define a type, default, enum or
required at the schema level. The message I'm getting is: "Undefined
type at `email`\n Did you try nesting Schemas? You can only nest using
refs or arrays.". This happens when I'm throwing the fields into the
Schema class on:

new mongoose.Schema(this.convert_fields(schema.fields))

When I output converted_fields (the transformed model), I see it's
been generated correctly:

{
    email: {
        type: [Function: SchemaString]
    },
    first_name: {
        type: [Function: SchemaString]
    },
    last_name: {
        type: [Function: SchemaString]
    },
    password: {
        type: [Function: SchemaString]
    },
    status: {
        enum: ['active', 'inactive']
    },
    created_at: {
        type: [Function: SchemaDate]
    },
    updated_at: {
        type: [Function: SchemaDate]
    },
    last_login: {
        type: [Function: SchemaDate]
    }
}​

If I don't specify any properties for the fields, the model is setup
correctly.

Thanks,

Dave

--

-- 
http://mongoosejs.com
http://github.com/learnboost/mongoose
You received this message because you are subscribed to the Google
Groups "Mongoose Node.JS ORM" group.
To post to this group, send email to mongoose-orm@...
To unsubscribe from this group, send email to
mongoose-orm+unsubscribe@...
For more options, visit this group at
http://groups.google.com/group/mongoose-orm?hl=en

dup key MongoError: E11000 when trying to do an upsert

Mongoose won't output Array in nested Schema

Is there limit to how deep your objects can go in Mongoose?

[
{
  _id: 4fb073e2c11f3348c48857f3,
  name: 'Name',
  location: [
    {
      title: 'title',
      city: 'New York',
      country: 'United States',
      languages: [Object],  <<--- This should be a [String] like:
['English', 'Spanish', ...]
    }
  ]
},
{
  _id: 4fb073e2c11f3348c48857fc,
  name: 'Name',
  [...]
}
]
Not sure why the "languages" Array is outputting "[Object]" instead of
and Array of Strings. I've also notice that if I remove the "[]" and
just use a String data type in the Schema it outputs a comma delimited
list as a String

get the Model from the document instance?

Universal statics for Schemas & using JSON.stringify for search queries

Hello all,

I have a question on how (if it's possible!) to attach a static method
to the Schema class directly, so that the same method would be
available on all models? For example, using the docs, could I do
something like

Schema.prototype.statics.search = function search (name, cb) {
  return this.where('name', new RegExp(name, 'i')).run(cb);
}

is there a way to make the 'search' method universal? So that whatever
model was initiated, the 'this' would apply to that model. Then I
could call

Animal.search('Rover', function (err) {
  if (err) ...
})

or

Alien.search('ET', function(err) {
}

and this would always produce the search Animal.where... or
Alien.where... I tried fiddling with Schema.prototype but I couldn't
get it to work.

Second question - if I do like so

var searchTerms = {};
searchTerms['name'] = 'Joe';

searchTerms = JSON.stringify(searchTerms);

Person.find(searchTerms, function(err, people) {...});

is returning all records, and not returning only docs with { 'name' :
'Joe'} ??

Much thanks!

returning values from nested functions in virtuals

headed to jsconf.ar

I'm headed to Argentina for jsconf. Anyone else?

Should methods and statics be asynchronous or not and what are the implications?

Why doesn't MongooseJS correctly populate my fields?

I'm trying to adapt the example here

http://mongoosejs.com/docs/populate.html

I have removed stories and am trying to add a 'friends' field
instead.  My code is as follows

var PersonSchema = new Schema({
    name    : String
  , age     : Number
  , friends : [{ type: Schema.ObjectId, ref: 'Person' }]
});

var Person = mongoose.model('Person', PersonSchema);

var aaron = new Person({ name: 'Aaron', age: 100 });
var bill = new Person({ name: 'Bill', age: 97 });

aaron.save(function (err) {
    if (err) throw err;
    bill.save(function(err) {
        if (err) throw err;
        var charlie = new Person({ name: 'Charlie', age: 97, friends:
[aaron._id, bill._id] });
        charlie.save(function(err) {
            if (err) throw err;
            Person
            .findOne({name: 'Charlie'})
            .populate('friends')
            .run(function(err, friends) {
                if (err) throw err
                console.log('JSON for friends is: ', friends);
                db.disconnect();

            });

        });

    });

});

It prints out the following text

JSON for friends is:  { name: 'Charlie',
  age: 97,
  _id: 4fb302beb7ec1f775e000003,
  stories: [],
  friends:
   [ { name: 'Aaron',
       age: 100,
       _id: 4fb302beb7ec1f775e000001,
       stories: [],
       friends: [] },
     { name: 'Bill',
       age: 97,
       _id: 4fb302beb7ec1f775e000002,
       stories: [],
       friends: [] } ] }

In other words it is printing out the 'charlie' object.  My desired
functionality is for MongooseJS to use ObjectIds in the friends field
and populate an array with the matching objects (aaron and bill).  In
other words something more along the lines of

[ { name: 'Aaron',
       age: 100,
       _id: 4fb302beb7ec1f775e000001,
       stories: [],
       friends: [] },
     { name: 'Bill',
       age: 97,
       _id: 4fb302beb7ec1f775e000002,
       stories: [],
       friends: [] } ]

What am I doing wrong?