return bluebird from within the module, so adapters can re-use it. also would be useful if lazy-promises are implemented in later versions.

/* src/Promise.js */

module.exports = require('bluebird');

Think mixins.

For example:

var Post = db.createModelClass({
  schema: {
    created: {
      type: 'date',
      default: function () {
        return new Date();
      }
    }
  }
});

with current model's related data too.

Maybe I'm missing something but I don't think Model.collection() is exhibiting the expected behavior in the case where it's being called from a Model with a badly-configured collectionClass.

The way I see it, if new C(options) isn't an instance, that function should throw an error, not return a new object (which won't be an instance either). There also doesn't really seem to be the need for the isInstance() function as, excluding the duplicated code block, it's called just the once.

Relevant code: https://github.com/fahad19/firenze/blob/master/src/Model.js#L418-L440

PS - Low hanging fruit for duplicated code: #37

By default, whenever a rule fails, that rule's message is returned and other rules (if any) are not processed for a particular field.

Allow an option to process multiple rules per field upon failure too.

For example, in CakePHP: http://book.cakephp.org/2.0/en/models/data-validation.html#last

Right now, the class itself is passed when creating a new Database instance:

var f = require('firenze');

var db = new f.Database({
  adapter: MysqlAdapter
});

Make it possible so an instance can be set too, that way some adapters can be configured in a certain way:

var db = new f.Database(
  adapter: new MysqlAdapter(customConfig)
);

model.find(1);

// which should be equivalent to:
model.find('first', {
  conditions: {
    id: 1
  }
});

OR:

model.findById();
model.findByKey();
model.findBy(field, options = {});

with dot-props.

From the examples for fetching records and counting in the guide I am getting .find(...).where(...).count(...).then is not a function

My function looks like this

router.get('/count', function (req, res, next) {
  var users = new UsersCollection();
  users.find()
    .where({})
    .count()
    .then(function (count) {
      console.log('Total number of published posts:', count);
    });
});

Hey, awesome project! Wondering whether browser support is in the roadmap?

with Catcher when save fails.

RIght now, they can only be created via Database instance.

Like:

• MySQL
• Postgresql
• MongoDB

Knex (the query builder this ORM uses) does not construct prepared statements to make queries. Parameterized queries are the correct way to construct SQL statements to efficiently and safely protect against SQLi attacks.

I'm aware of at least two other libraries that correctly construct SQL queries, and each supports a variety of databases (although sequel does not support sqlite):

• https://github.com/brianc/node-sql
• https://hiddentao.github.io/squel/

Perhaps this library could switch from Knex to one of those? (My personal preference is with node-sql since it supports sqlite).

like:

var posts = new Posts({
  conditions: {
    published: true
  }
});

all future posts.find()s would return published posts only.

Since they are all promises, figure a way out for for making the actual query only after .then() is called.

https://www.npmjs.com/package/dot-prop

support callbacks like these at Model level:

• beforeValidate()
• afterValidate()
• beforeSave()
• afterSave()
• beforeDelete()
• afterDelete()

also support these methods without callbacks too (by passing something like {callbacks: false} in options:

• save()
• delete()
• validate()

I am trying to get the sum of a column but it's not working properly. it returns an array of rows rather than a single value. My code looks like this:

pendings.find()
    .select(function (column) {
      return column('amount')
        .sum();
    })
    .all()
    .then(function (models) {}):

I'm fairly new to this and I've figured out how to use firenze to query a database and get results but I cannot get my results to the global scope to use elsewhere in my code. How do you get the results out?

var f = require('firenze');
var Database = f.Database;
var MysqlAdapter = require('firenze-adapter-mysql');

var db = new Database({
    adapter: MysqlAdapter,
    host: '127.0.0.1',
    database: 'jlg',
    user: 'root',
    password: ''
});

var Records = db.createCollection({
  table: 'questions',
  alias: 'qs',
});

var questions = new Records();
var STORE_RESULTS_HERE = "";

questions.find()
  .where({
    id: 1
  })
  .first()
  .then(function (questions) {

    // or convert to plain object
    var questionObject = questions.toJSON();
    var answer = questionObject.answer;
   STORE_RESULTS_HERE = answer;
  });

 console.log(STORE_RESULTS_HERE); //returns empty string

useful for noSQL databases.

for example:

schema: {
  'directField': {},
  'firstField.nestedField': {
    type: 'string',
    validate: {...}
  }
}

https://github.com/fahad19/firenze/blob/master/src/Model.js#L448

Lodash docs: http://devdocs.io/lodash/index#get

Like:

var post = new Post({
  title: 'My Post',
  body: 'blah...'
});

• hasOne
• belongsTo
• hasMany
• hasAndBelongsToMany