Seems interesting ! I would definitely like more ORM for node.js technologies.
The concurrent are Sequelize (http://sequelizejs.com/) and Bookshelf (http://bookshelfjs.org/), both very mature libraries (look at the Sequelize test suite, it's quite impressing !).
Iroal, any comment on the rdb choices against these two big guys ? How can we expect rdb to evolve ?
Rdb is used in commercial products at my employer Timpex (www.timpex.no). So it will definitely be maintained. The code was initially closed source in csharp, we refined it and released it as OSS in javascript.
It was created because we needed a solution with persistence ignorance and that does not have any constraints on foreign key naming, columns, table and so on. By persistence ignorance I mean not needing to call model.save() or pass the connection around everywhere - just edit the properties and commit the transaction.
Everything in rdb is developed TDD outside-in. So it has a lot of unit tests, but not that many integration tests. There are running examples in the demo repo though that could be considered as kind of integration tests.
Choices against sequelize and bookshelf: that is not my mission. If you want a closer integration with express.js, those orms are a better fit than rdb. My main focus on rdb was to keep the API simple and expose as little of the interior as possible - Tell Dont Ask principle.
How to expect rdb to evolve ?
-domain logic
-aggregate functions
-order by
-support sqlLite
I really really really like Knex. While Mongo claims to be "easy" and "js-native", It's far easier doing complicated queries with Knex on Postgres than on Mongo with the official client.
I work on a mongo project and doing aggregate queries is really ugly and painful. Everyone praising mongo probably never made "advanced" queries like that or dismissed SQL as shitty and unsecure without ever using it.
Likely also better performance with just using Knex.
Any ORM likely adds overhead, Sequelize definitely does, although we keep working on reducing that overhead - But inevitably features === overhead.
Great question. To me what Node is missing most is a ORM that isn't tied to a backend -- relationships can easily be expressed without needing to know whether data is fetched through an API or through SQL. This is how ORM is often done in frontend JS. We're working on and using such a backend-agnostic Node lib, but I don't think it's polished enough for release yet.
please stick with promises. Promises are the only sane way to deal with async in JS. With people starting to use async/await they become even more compelling.
The people who defend callbacks either don't understand the benefits that promises provide, don't know about async/await or are suffering from stockholm syndrome.
Callbacks do not pass the reversibility test. If everyone had started out with promises and / or async/await, and someone proposed callbacks as a way to deal with this instead, they'd be dismissed as a fool. They're an accident of history and we should forget about them as quickly as possible.
Callbacks allow await/defer in Iced CoffeeScript, not to mention the other async libs as stated above.
Promises don't really offer any benefit to program structure overall, generally devs just end up creating long chains of anonymous functions rather than long nests of anonymous functions. Promises actually discourage flat code (and functional programming) for that reason. I understand they seem attractive but become a hack in complex situations.
Oh ok, was just wondering about your reasons and that clears things up. That's a good read as well. But I think promises give you a way to compose them in a way that callbacks don't. With promises you can call easily call a function when multiple promises are fulfilled.
Actually would argue that Promises are less composable since you're forced to use whatever control flow paradigm the Promise library has provided or add another library to handle control flow.
By utilizing callbacks, you are free to use Async.js[0] or Step.js[1] to solve the problem you described. These libraries are great since they give you control over parallel vs series execution of the pre-requisite functions as well as solving more complex control-flow problems such as throttling, etc[2] (See link for more examples).
edit: Yes, you can also use similar control-flow libraries with Promises (that follow the specification) to achieve similar results but then the argument for using promises for the sake of control-flow breaks down.
At least a part of promises, the then function, is standardized through Promises/A+. This way you can easily combine different promise libraries to do things like:
- sequential execution
- parallel execution and wait for all of them to finish
ORMs are not really required in a Node/Mongo/JSON setup anymore:
- JSON's nature is already very 'object oriented' and I use in code JSON data like it saved—no translation beetween clunky SQL and objects is necessary (if I have a DB which saves JSON natively like Mongo)
- Mongo allows to directly save JSON and stuff like migrations is stuff from the past since tables/collections don't have to be created
- Mongo's Native Driver is low level and at the same time fully sufficient, the syntax is not beautiful and tons of libs sit on top to make it beautiful but I still don't see the need for a real ORM
So, Mongo's Native Driver is your best friend and validations are often a matter of a few lines. Or did I miss anything which is life saving I get from ORMs in a Node/Mongo setup?
Good point and I just checked: rdb seems to be for SQL based DBs.
But I am wondering who is using SQL based DBs with Node, feels ancient to me, except you build the next datastore for a bank but even then. Also Postgres with its JSON options does not give the feeling, flexibility and speed as Node/Mongo.
I could imagine that the larger part of Node users are working with Mongo, or not?
Mongo is great for when you're rapidly developing a product and/or still operating at a small-medium scale.
Once you start to really scale, you'll start to find a couple parts of MongoDB break-down:
1. MongoDB has no concept of transactions and is not ACID compliant. These short-comings seem innocuous enough at first, but you end up with some crazy potential race conditions that you just end up praying you never face.
2. Distributed MongoDB layers are difficult to implement as well as maintain.
3. MongoDB Replica sets are unpredictable and unreliable in the speed at which they are able to stay up to date and require changes to your code to fully utilize (since you need to ensure you are always reading from a replica when you can, but only ever writing to the master MongoDB instance)
4. At scale, MongoDB will consistently perform worse than Postgres for CRUD-based operations
5. Do you have true relations between documents? Do you ever use Mongoose's convenient `populate()` functionality? If so, you are now making multiple db queries in series when trying to fetch a document(s) from a single collection. This starts to really hurt your query times once you get enough documents/relations in your mongo collections.
I'm sure I'm missing some, but these are some of the areas where MongoDB has fallen down for me in the past.
> Mongo is great for when you're rapidly developing a product and/or still operating at a small-medium scale.
Yesterday somebody from a node-based consultancy gave a talk at work about microservices, where he remarked in passing that they tend to start projects with mongo, then wait for a schema to kind of 'fall out' of the application as it takes shape, and then switch to postgres or something. Which doesn't seem like an awful idea.
Maybe if you are working with data which inherently has a relational structure using a relational database makes sense. Maybe if you need to ensure transactional consistency, you want to use a data-store which is ACID compliant.
You know: There's no silver hammer. Use the right tool for the right job. Etc etc.
Just a though. A sprinkle of old man's dust onto this new hip generation who thinks JSON solves all the problems in the world.
Rdb (Relational Database) is meant only for Relation Databases (sql). I have no plans on supporting document databases - that would probably a bad compromize. And the api would be affected in a negative way.
The concurrent are Sequelize (http://sequelizejs.com/) and Bookshelf (http://bookshelfjs.org/), both very mature libraries (look at the Sequelize test suite, it's quite impressing !). Iroal, any comment on the rdb choices against these two big guys ? How can we expect rdb to evolve ?