Initial commit

Author: beeman

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.idea

.jscsrc

@@ -0,0 +1,24 @@
+{
+  "preset": "google",
+  "excludeFiles": ["node_modules"],
+  "requireCurlyBraces": [
+     "else",
+     "for",
+     "while",
+     "do",
+     "try",
+     "catch"
+  ],
+  "disallowMultipleVarDecl": "exceptUndefined",
+  "disallowSpacesInsideObjectBrackets": null,
+  "maximumLineLength": {
+     "value": 120,
+     "allowComments": true,
+     "allowRegex": true
+  },
+  "validateJSDoc": {
+    "checkParamNames": false,
+    "checkRedundantParams": false,
+    "requireParamTypes": true
+  }
+}

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Bram Borggreve
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,74 @@
+PAGINATION
+=============
+
+This module is designed for the [Strongloop Loopback](https://github.com/strongloop/loopback) framework.
+It provides a mixin that makes it easy to add pagination to an existing model
+
+INSTALL
+=============
+
+```bash
+npm install --save loopback-ds-pagination-mixin
+```
+
+SERVER.JS
+=============
+
+In your `server/server.js` file add the following line before the
+`boot(app, __dirname);` line.
+
+```javascript
+...
+var app = module.exports = loopback();
+...
+// Add Readonly Mixin to loopback
+require('loopback-ds-pagination-mixin')(app);
+
+boot(app, __dirname, function(err) {
+  'use strict';
+  if (err) throw err;
+
+  // start the server if `$ node server.js`
+  if (require.main === module)
+    app.start();
+});
+```
+
+CONFIG
+=============
+
+To use with your Models add the `mixins` attribute to the definition object of your model config.
+
+```json
+{
+    "name": "Item",
+    "properties": {
+        "name": "String",
+        "description": "String",
+        "status": "String"
+    },
+    "mixins": {
+        "Pagination": {
+            "config": {
+                "limit": "10"
+            }
+        }
+    }
+}
+```
+
+
+TESTING
+=============
+
+Run the tests in `test.js`
+
+```bash
+  npm test
+```
+
+Run with debugging output on:
+
+```bash
+  DEBUG='loopback-ds-pagination-mixin' npm test
+```

circle.yml

@@ -0,0 +1,3 @@
+machine:
+  node:
+    version: 0.10.22

index.js

@@ -0,0 +1,102 @@
+var debug = require('debug')('loopback-ds-paginate-mixin');
+var utils = require('loopback-datasource-juggler/lib/utils');
+var assert = require('assert');
+var _ = require('lodash');
+
+function Paginate(Model, config) {
+  'use strict';
+
+  var mixinName = 'Paginate';
+  var modelName = Model.definition.name;
+  var debugPrefix = mixinName + ': ' + modelName + ': ';
+  debug(debugPrefix + 'Loading with config %o', config);
+
+  Model.paginate = function(page, limit, query, cb) {
+    cb = cb || utils.createPromiseCallback();
+
+    // Check if page is passed otherwise default to 1
+    if (_.isUndefined(page)) {
+      debug(debugPrefix + 'paginate: page undefined: %s', page);
+      page = 1;
+    } else {
+      debug(debugPrefix + 'paginate: page defined: %s', page);
+    }
+
+    // Check if limit is passed otherwise set to mixin config or default
+    if (_.isUndefined(limit)) {
+      limit = config.options.limit || 10;
+    }
+
+    // Do some assertions
+    // TODO: These values should never be negative
+    assert(typeof page, 'number', 'Page should always be a number');
+    assert(typeof limit, 'number', 'Limit should always be a number');
+
+    // Define the initial params object
+    var params = {
+      skip: (page - 1) * limit,
+      limit: limit
+    };
+
+    // Check if additional query parameters are passed
+    if (!_.isUndefined(query)) {
+
+      // Check each of the following properties and add to params object
+      var queryParams = ['fields', 'include', 'where', 'order'];
+      queryParams.map(function(queryParam) {
+
+        if (!_.isUndefined(query[queryParam])) {
+          params[queryParam] = query[queryParam];
+
+          debug(debugPrefix + 'paginate: adding param: %s = %o', queryParam,
+            query[queryParam]);
+        }
+      });
+
+    }
+
+    debug(debugPrefix + 'paginate: params: %o', params);
+
+    // Define where query used for counter
+    var countWhere = params.where || {};
+
+    // Get all the objects based on the params
+    Model.all(params).then(function(items) {
+
+      // Get total number of objects based on countWhere
+      Model.count(countWhere).then(function(count) {
+
+        // Format the result
+        var result = {
+          paging: {
+            totalItems: count,
+            totalPages: Math.ceil(count / limit),
+            itemsPerPage: limit,
+            currentPage: page
+          },
+          result: items
+        };
+
+        debug(debugPrefix + 'paginate: result: %o', result);
+        cb(null, result);
+      }).catch(cb);
+    }).catch(cb);
+
+    return cb.promise;
+  };
+
+  Model.remoteMethod('paginate', {
+    accepts: [
+      {arg: 'page', type: 'number'},
+      {arg: 'limit', type: 'number'},
+      {arg: 'query', type: 'object'}
+    ],
+    returns: {arg: 'result', type: 'string', root: true},
+    http: {path: '/paginate', verb: 'get'}
+  });
+
+}
+
+module.exports = function mixin(app) {
+  app.loopback.modelBuilder.mixins.define('Paginate', Paginate);
+};

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "loopback-ds-paginate-mixin",
+  "version": "1.0.0",
+  "description": "A mixin to enable easy pagination for a loopback Model.",
+  "main": "index.js",
+  "keywords": [
+    "loopback",
+    "strongloop",
+    "mixin"
+  ],
+  "author": "Bram Borggreve",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fullcube/loopback-ds-paginate-mixin"
+  },
+  "dependencies": {
+    "debug": "2.x",
+    "lodash": "3.9.3",
+    "loopback-datasource-juggler": "2.30.1"
+  },
+  "devDependencies": {
+    "bluebird": "2.9.24",
+    "chai": "latest",
+    "jscs": "1.13.x",
+    "jshint": "latest",
+    "loopback": "2.x",
+    "loopback-connector-mongodb": "^1.11.1",
+    "loopback-datasource-juggler": "^2.30.1",
+    "loopback-testing": "1.x",
+    "mocha": "latest",
+    "mocha-sinon": "latest",
+    "sinon": "latest",
+    "sinon-chai": "latest"
+  },
+  "scripts": {
+    "lint": "jscs index.js && jshint index.js",
+    "test": "mocha -R spec --timeout 10000 test.js",
+    "test:watch": "npm run test -- -w",
+    "pretest": "npm run lint"
+  }
+}

test.js

@@ -0,0 +1,124 @@
+/* jshint mocha: true */
+
+var debug = require('debug')('loopback-ds-pagination-mixin');
+
+var loopback = require('loopback');
+var lt = require('loopback-testing');
+
+var chai = require('chai');
+var expect = chai.expect;
+var assert = chai.assert;
+
+var sinon = require('sinon');
+chai.use(require('sinon-chai'));
+require('mocha-sinon');
+
+// Create a new loopback app.
+var app = loopback();
+
+// Set up promise support for loopback in non-ES6 runtime environment.
+global.Promise = require('bluebird');
+
+// import our Changed mixin.
+require('./')(app);
+
+// Configure datasource
+dbConnector = loopback.memory();
+
+describe('loopback datasource paginate mixin', function() {
+
+  beforeEach(function(done) {
+
+    // A model with 2 Changed properties.
+    var Item = this.Item = loopback.PersistedModel.extend('item', {
+      name: String,
+      description: String,
+      status: String
+    }, {
+      mixins: {
+        Paginate: {
+          options: {
+            limit: '10'
+          }
+        }
+      }
+    });
+
+    Item.attachTo(dbConnector);
+    app.model(Item);
+
+    app.use(loopback.rest());
+    app.set('legacyExplorer', false);
+    done();
+  });
+
+  lt.beforeEach.withApp(app);
+
+  describe('Testing behaviour', function() {
+    for(var i = 1; i <= 49; i++) {
+      lt.beforeEach.givenModel('item', {
+        name:'Item' + i,
+        description: 'This is item with id' + i,
+        status: 'active'
+      }, 'item' + i);
+    }
+
+
+    describe('Model.find', function() {
+      it('Default find operation.', function(done) {
+
+        this.Item.find().then(function(result){
+          assert.equal(result.length, 49, 'Should return all items');
+          done();
+        });
+
+      });
+    });
+
+    describe('Model.paginate', function() {
+      it('Paginate without parameters', function(done) {
+        this.Item.paginate().then(function(result){
+          console.log('result', result.paging);
+          assert.equal(result.paging.totalItems, 49, 'Should return total items');
+          assert.equal(result.paging.totalPages, 5, 'Should return total pages');
+          assert.equal(result.paging.itemsPerPage, 10, 'Should items per page');
+          assert.equal(result.paging.currentPage, 1, 'Should return current page');
+          assert.equal(result.result.length, 10, 'Should return one page');
+          done();
+        });
+      });
+
+      it('Paginate with where filter', function(done) {
+        var page = 1;
+        var limit = 10;
+        this.Item.paginate(page, limit, {
+          where: {
+            name: 'Item1'
+          }
+        }).then(function(result){
+          assert.equal(result.paging.totalItems, 1, 'Should return total items');
+          assert.equal(result.paging.totalPages, 1, 'Should return total pages');
+          assert.equal(result.paging.itemsPerPage, limit, 'Should items per page');
+          assert.equal(result.paging.currentPage, page, 'Should return current page');
+          assert.equal(result.result.length, 1, 'Should return the right number of items');
+          done();
+        });
+      });
+
+
+      it('Paginate with small page', function(done) {
+        var page = 1;
+        var limit = 4;
+        this.Item.paginate(page, limit).then(function(result){
+          assert.equal(result.paging.totalItems, 49, 'Should return total items');
+          assert.equal(result.paging.totalPages, 13, 'Should return total pages');
+          assert.equal(result.paging.itemsPerPage, limit, 'Should items per page');
+          assert.equal(result.paging.currentPage, page, 'Should return current page');
+          assert.equal(result.result.length, limit, 'Should return the right number of items');
+          done();
+        });
+      });
+    });
+
+  });
+});