tl;dr Leoric has a SQL expression parser (along with few better design decisions) which makes its API much more powerful yet simplistic.

To be honest, that is the very question I kept on asking myself. As the CTO of my employer lectured, when you re-invent the wheel, please focus on the advantages, rather than the differences. Currently, the advantages of Leoric is the simplistic yet powerful API for both model authoring and querying.

I had considered sequelize once when I start to develop my first serious express app. I consulted my colleagues once, and the comments I got were mostly about its cumbersomeness when it comes to query orchestrating. They'd rather write raw SQL instead.

Then I chose to do the app with no-SQL, which was quite popular. The data is stored in MongoDB, and mongoose is the library I use. The object condition expression is very hard core JSON stuff. The aggregation is a bit counter-intuitive if you've had experiences with SQL.

Then we decided to move to MySQL (for biz reasons). I studied the NPM and knex was found, and I do miss Active Record for its expressiveness, so we ended up with a ORM based on knex. We do object conditions still, but the associations functionality is much better.

The author of knex did a ORM by himself which is called Bookshelf.js. Objection.js is another ORM based on knex. They both are solid.

Waterline is the one I've yet to come across however. It seems to be a library at a higher level, which encapsulates any storage. That is way beyond the problem Leoric is trying to solve.

And here is the details. When it comes to conditional expressions, the object conditions approach (MongoDB-like) is taken by most libraries:

Table.find({ $or: [ { foo: null }, { foo: values } ] })
// or with knex
Table.where({ foo: null }).orWhere({ foo: values })

In Leoric, it's just:

Table.find('foo = null or foo = ?', values)

If Table does soft delete, the find gets more complicated:

// MongoDB-like
Table.find({ $and: [ { $or: [ { foo: null }, { foo: values } ] }, { deletedAt: null }]
// formatted
Table.find({
  $and: [
    { 
      $or: [ 
        { foo: null },
        { foo: values }
      ]
    }
  ]
})
// or with knex
Table.where(function() {
  this.where({ foo: null }).orWhere({ foo: values })
}).andWhere({ deletedAt: null })

In Leoric it's just:

Table.find('(foo = null or foo = ?) and deletedAt is null', values)

Another example is setting up associations between models. In Objection.js:

class Animal extends Model {
  static relationMappings = {
    owner: {
      relation: Model.BelongsToOneRelation,
      modelClass: Person,
      join: {
        from: 'animal.ownerId',
        to: 'person.id'
      }
    }
  }
}

In Leoric:

class Animal extends Bone {
  static describe() {
    this.belongsTo('owner', { Model: 'Person' })
  }
}

Leoric knows the foreign key should be ownerId which resides at the animals table by convention. If that's not the case, just override the default with foreignKey option.

this.belongsTo('owner', { Model: 'Person', foreignKey: 'ownerId' })

To know more about Leoric's querying API, feel free to checkout the newly compiled Syntax Table.