penseur - npm Package Compare versions

Comparing version 1.2.0 to 1.3.0

lib/table.js

@@ -207,1 +207,60 @@ // Load Modules
 };
+
+
+internals.Table.prototype.changes = function (criteria, each, callback) {
+
+    var self = this;
+
+    callback = callback || each;
+
+    var request = this._table;
+    if (criteria !== '*') {
+        if (typeof criteria !== 'object') {
+            request = this._table.get(criteria);
+        }
+        else if (Array.isArray(criteria)) {
+            request = this._table.getAll(RethinkDB.args(criteria));
+        }
+        else {
+            request = this._table.filter(criteria);
+        }
+    }
+
+    request.changes().run(this._db._connection, { includeStates: true }, function (err, cursor) {
+
+        if (err) {
+            return self.error('changes', err, criteria, callback);
+        }
+
+        var isReady = false;
+        cursor.each(function (err, item) {
+
+            if (err) {
+                return self.error('changes', err, criteria, each);
+            }
+
+            if (item.state) {
+                isReady = (item.state === 'ready');
+                return;
+            }
+
+            if (isReady) {
+                return each(null, { before: item.old_val || null, after: item.new_val || null });
+            }
+        });
+
+        return callback(null, new internals.Cursor(cursor));
+    });
+};
+
+
+internals.Cursor = function (cursor) {
+
+    this._cursor = cursor;
+};
+
+
+internals.Cursor.prototype.close = function () {
+
+    this._cursor.close();
+};

package.json

 {
   "name": "penseur",
   "description": "Lightweight RethinkDB wrapper",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "author": "Eran Hammer <[e-mail]> (http://hueniverse.com)",
@@ -12,3 +12,3 @@ "repository": "git://github.com/hueniverse/penseur",
   "engines": {
-    "node": ">=0.10.32"
+    "node": ">=0.10.40"
   },
@@ -15,0 +15,0 @@ "dependencies": {

test/table.js

 // Load modules
 
 var Code = require('code');
+var Hoek = require('hoek');
 var Lab = require('lab');
@@ -98,2 +99,22 @@ var Penseur = require('..');
         });
+
+        it('returns the requested objects found (none)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+                db.test.insert([{ id: 1, a: 1 }, { id: 2, a: 2 }, { id: 3, a: 1 }], function (err, keys) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.get([4, 5, 6], function (err, result) {
+
+                        expect(err).to.not.exist();
+                        expect(result).to.deep.equal([]);
+                        done();
+                    });
+                });
+            });
+        });
     });
@@ -577,2 +598,266 @@
     });
+
+    describe('changes()', function () {
+
+        it('reports on a record update (*)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.after.id);
+                };
+
+                db.test.changes('*', each, function (err, cursor) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.insert({ id: 1, a: 1 }, function (err, keys) {
+
+                        expect(err).to.not.exist();
+
+                        db.test.update(1, { a: 2 }, function (err) {
+
+                            expect(err).to.not.exist();
+
+                            expect(changes).to.deep.equal([1, 1]);
+                            cursor.close();
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+
+        it('reports on a record update (id)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.after.id);
+                };
+
+                db.test.insert([{ id: 1, a: 1 }], function (err, keys1) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.changes(1, each, function (err, cursor) {
+
+                        expect(err).to.not.exist();
+
+                        db.test.update(1, { a: 2 }, function (err, keys2) {
+
+                            expect(err).to.not.exist();
+
+                            db.test.insert({ id: 2, a: 2 }, function (err) {
+
+                                expect(err).to.not.exist();
+
+                                expect(changes).to.deep.equal([1]);
+                                cursor.close();
+                                done();
+                            });
+                        });
+                    });
+                });
+            });
+        });
+
+        it('reports on a record update (ids)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.after.id);
+                };
+
+                db.test.insert([{ id: 1, a: 1 }], function (err, keys1) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.changes([1, 2], each, function (err, cursor) {
+
+                        expect(err).to.not.exist();
+
+                        db.test.update(1, { a: 2 }, function (err, keys2) {
+
+                            expect(err).to.not.exist();
+
+                            db.test.insert({ id: 2, a: 2 }, function (err) {
+
+                                expect(err).to.not.exist();
+
+                                expect(changes).to.deep.equal([1, 2]);
+                                cursor.close();
+                                done();
+                            });
+                        });
+                    });
+                });
+            });
+        });
+
+        it('reports on a record update (query)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.after.id);
+                };
+
+                db.test.insert([{ id: 1, a: 1 }], function (err, keys1) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.changes({ a: 2 }, each, function (err, cursor) {
+
+                        expect(err).to.not.exist();
+
+                        db.test.update(1, { a: 2 }, function (err, keys2) {
+
+                            expect(err).to.not.exist();
+
+                            db.test.insert({ id: 2, a: 2 }, function (err) {
+
+                                expect(err).to.not.exist();
+
+                                expect(changes).to.deep.equal([1, 2]);
+                                cursor.close();
+                                done();
+                            });
+                        });
+                    });
+                });
+            });
+        });
+
+        it('reports on a record update (delete)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.before.id + ':' + (item.after === null));
+                };
+
+                db.test.insert([{ id: 1, a: 1 }], function (err, keys1) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.changes(1, each, function (err, cursor) {
+
+                        expect(err).to.not.exist();
+
+                        db.test.remove(1, function (err) {
+
+                            expect(err).to.not.exist();
+                            expect(changes).to.deep.equal(['1:true']);
+                            cursor.close();
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+
+        it('reports on a record update (id missing)', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    changes.push(item.after.id);
+                };
+
+                db.test.changes(1, each, function (err, cursor) {
+
+                    expect(err).to.not.exist();
+
+                    db.test.insert({ id: 1, a: 1 }, function (err, keys) {
+
+                        expect(err).to.not.exist();
+                        expect(changes).to.deep.equal([1]);
+                        cursor.close();
+                        done();
+                    });
+                });
+            });
+        });
+
+        it('errors on bad cursor', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.establish(['test'], function (err) {
+
+                expect(err).to.not.exist();
+
+                var changes = [];
+                var each = function (err, item) {
+
+                    if (err) {
+                        expect(err.message).to.equal('Database error');
+                        done();
+                    }
+                };
+
+                db.test.changes('*', each, function (err, cursor) {
+
+                    expect(err).to.not.exist();
+
+                    var orig = cursor._cursor._next;
+                    cursor._cursor._next = function (next) {
+
+                        cursor._cursor._next = orig;
+                        return next(new Error('kaboom'));
+                    };
+
+                    db.test.insert({ id: 1, a: 1 }, function (err, keys) {
+
+                        expect(err).to.not.exist();
+                    });
+                });
+            });
+        });
+
+        it('errors on invalid table', function (done) {
+
+            var db = new Penseur.Db('penseurtest');
+            db.table('invalid');
+            db.connect(function (err) {
+
+                db.invalid.changes('*', function (err, item) {
+
+                    expect(err).to.exist();
+                    done();
+                });
+            });
+        });
+    });
 });

No alert changes

Improved metrics

Total package byte prevSize

40796

increased by32.1%

Lines of code

909

increased by33.87%

No dependency changes