2.3.0

It's now possible to limit the models rest routes are created for. This
is done via a `models` option that can be simple to complex. The readme
has been updated to reflect this.

.eslintrc

@@ -1,9 +1,3 @@
 {
-  "plugins": [
-    "ava"
-  ],
-  "extends": [
-    "pichak",
-    "plugin:ava/recommended"
-  ]
+  "extends": "pichak"
 }

CONTRIBUTING

@@ -1,7 +0,0 @@
-Commit Message
-===============
-Please follow [this convention](http://karma-runner.github.io/1.0/dev/git-commit-msg.html) for git commit message.
-
-Lint
-====
-Please lint your code using `npm run lint` (also `npm run lint -- --fix` to auto-fix).

README.md

@@ -1,4 +1,4 @@
-hapi-sequelize-crud [![CircleCI](https://circleci.com/gh/mdibaiee/hapi-sequelize-crud.svg?style=svg)](https://circleci.com/gh/mdibaiee/hapi-sequelize-crud)
+hapi-sequelize-crud
 ===================
 
 Automatically generate a RESTful API for your models and associations
@@ -11,9 +11,6 @@ npm install -S hapi-sequelize-crud
 
 ##Configure
 
-Please note that you should register `hapi-sequelize-crud` after defining your
-associations.
-
 ```javascript
 // First, register hapi-sequelize
 await register({
@@ -33,84 +30,36 @@ await register({
     prefix: '/v1',
     name: 'db', // the same name you used for configuring `hapi-sequelize` (options.name)
     defaultConfig: { ... }, // passed as `config` to all routes created
-
-    // You can specify which models must have routes defined for using the
-    // `models` property. If you omit this property, all models will have
-    // models defined for them. e.g.
     models: ['cat', 'dog'] // only the cat and dog models will have routes created
-
     // or
-    models: [
+    models: {
       // possible methods: list, get, scope, create, destroy, destroyAll, destroyScope, update
-      // the cat model only has get and list methods enabled
-      {model: 'cat', methods: ['get', 'list']},
-      // the dog model has all methods enabled
-      {model: 'dog'},
-      // the cow model also has all methods enabled
-      'cow',
-      // the bat model as a custom config for the list method, but uses the default config for create.
-      // `config` if provided, overrides the default config
-      {model: 'bat', methods: ['list'], config: { ... }},
-      {model: 'bat', methods: ['create']}
-    ]
+      cat: ['get', 'list'], // the cat model only has get and list methods enabled
+      dog: true, // the dog model has all methods enabled
+      bat: {
+        methods: ['list'],
+        config: { ... } // if provided, overrides the default config
+      }
+    }
   }
 });
 ```
 
 ### Methods
-* **list**: get all rows in a table
-* **get**: get a single row
-* **scope**: reference a [sequelize scope](http://docs.sequelizejs.com/en/latest/api/model/#scopeoptions-model)
-* **create**: create a new row
-* **destroy**: delete a row
-* **destroyAll**: delete all models in the table
-* **destroyScope**: use a [sequelize scope](http://docs.sequelizejs.com/en/latest/api/model/#scopeoptions-model) to find rows, then delete them
-* **update**: update a row
+* list: get all rows in a table
+* get: get a single row
+* scope: reference a [sequelize scope](http://docs.sequelizejs.com/en/latest/api/model/#scopeoptions-model)
+* create: create a new row
+* destroy: delete a row
+* destroyAll: delete all models in the table
+* destroyScope: use a [sequelize scope](http://docs.sequelizejs.com/en/latest/api/model/#scopeoptions-model) to find rows, then delete them
+* update: update a row
 
-## `where` queries
-It's easy to restrict your requests using Sequelize's `where` query option. Just pass a query parameter.
 
-```js
-// returns only teams that have a `city` property of "windsor"
-// GET /team?city=windsor
+Please note that you should register `hapi-sequelize-crud` after defining your
+associations.
 
-// results in the Sequelize query:
-Team.findOne({ where: { city: 'windsor' }})
-```
-
-You can also do more complex queries by setting the value of a key to JSON.
-
-```js
-// returns only teams that have a `address.city` property of "windsor"
-// GET /team?city={"address": "windsor"}
-// or
-// GET /team?city[address]=windsor
-
-// results in the Sequelize query:
-Team.findOne({ where: { address: { city: 'windsor' }}})
-```
-
-## `include` queries
-Getting related models is easy, just use a query parameter `include`.
-
-```js
-// returns all teams with their related City model
-// GET /teams?include=City
-
-// results in a Sequelize query:
-Team.findAll({include: City})
-```
-
-If you want to get multiple related models, just pass multiple `include` parameters.
-```js
-// returns all teams with their related City and Uniform models
-// GET /teams?include=City&include=Uniform
-
-// results in a Sequelize query:
-Team.findAll({include: [City, Uniform]})
-```
-
-## Full list of methods
+##What do I get
 
 Let's say you have a `many-to-many` association like this:
 
@@ -125,9 +74,8 @@ You get these:
 # get an array of records
 GET /team/{id}/roles
 GET /role/{id}/teams
-# might also append `where` query parameters to search for
+# might also append query parameters to search for
 GET /role/{id}/teams?members=5
-GET /role/{id}/teams?city=healdsburg
 
 # you might also use scopes
 GET /teams/{scope}/roles/{scope}

circle.yml

@@ -1,9 +0,0 @@
-machine:
-  node:
-    version: 6.5.0
-
-dependencies:
-  pre:
-    - npm prune
-  post:
-    - mkdir -p $CIRCLE_TEST_REPORTS/ava

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "hapi-sequelize-crud",
-  "version": "2.6.2",
+  "name": "@getable/hapi-sequelize-crud",
+  "version": "2.3.0",
   "description": "Hapi plugin that automatically generates RESTful API for CRUD",
   "main": "build/index.js",
   "config": {
@@ -9,14 +9,13 @@
     }
   },
   "scripts": {
-    "lint": "eslint src",
-    "test": "ava --require babel-register --source='src/**/*.js' --source='!build/**/*' --tap=${CI-false} src/**/*.test.js | $(if [ -z ${CI:-} ]; then echo 'tail'; else tap-xunit > $CIRCLE_TEST_REPORTS/ava/ava.xml; fi;)",
-    "tdd": "ava --require babel-register --source='src/**/*.js' --source='!build/**/*' --watch src/**/*.test.js",
+    "lint": "eslint src test",
+    "test": "echo \"Error: no test specified\" && exit 1",
     "build": "scripty",
     "watch": "scripty"
   },
   "repository": {
-    "git": "https://github.com/mdibaiee/hapi-sequelize-crud"
+    "git": "https://github.com/Getable/hapi-sequelize-crud"
   },
   "files": [
     "build"
@@ -24,29 +23,21 @@
   "author": "Mahdi Dibaiee <mdibaiee@aol.com> (http://dibaiee.ir/)",
   "license": "MIT",
   "devDependencies": {
-    "ava": "^0.16.0",
-    "babel-cli": "^6.14.0",
+    "babel-cli": "^6.10.1",
     "babel-plugin-add-module-exports": "^0.2.1",
     "babel-plugin-closure-elimination": "^1.0.6",
     "babel-plugin-transform-decorators-legacy": "^1.3.4",
-    "babel-plugin-transform-es2015-modules-commonjs": "^6.14.0",
-    "babel-preset-stage-1": "^6.13.0",
-    "babel-register": "^6.14.0",
-    "eslint": "^3.4.0",
-    "eslint-config-pichak": "^1.1.2",
-    "eslint-plugin-ava": "^3.0.0",
-    "ghooks": "^1.3.2",
-    "scripty": "^1.6.0",
-    "sinon": "^1.17.5",
-    "sinon-bluebird": "^3.0.2",
-    "tap-xunit": "^1.4.0"
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.10.3",
+    "babel-preset-stage-1": "^6.5.0",
+    "eslint": "2.10.2",
+    "eslint-config-pichak": "1.1.0",
+    "ghooks": "1.0.3",
+    "scripty": "^1.6.0"
   },
   "dependencies": {
-    "boom": "^4.0.0",
-    "joi": "^9.0.4",
-    "lodash": "^4.15.0"
-  },
-  "optionalDependencies": {
-    "babel-polyfill": "^6.13.0"
+    "babel": "5.8.3",
+    "boom": "^3.2.2",
+    "joi": "7.2.1",
+    "lodash": "4.0.0"
   }
 }

src/crud.js

@@ -1,39 +1,15 @@
 import joi from 'joi';
-import path from 'path';
 import error from './error';
 import _ from 'lodash';
 import { parseInclude, parseWhere } from './utils';
 import { notFound } from 'boom';
-import * as associations from './associations/index';
-import getConfigForMethod from './get-config-for-method.js';
 
-const createAll = ({
-  server,
-  model,
-  prefix,
-  config,
-  attributeValidation,
-  associationValidation,
-  scopes,
-}) => {
+const createAll = ({server, model, prefix, config}) => {
   Object.keys(methods).forEach((method) => {
-    methods[method]({
-      server,
-      model,
-      prefix,
-      config: getConfigForMethod({
-        method,
-        attributeValidation,
-        associationValidation,
-        config,
-        scopes,
-      }),
-    });
+    methods[method]({server, model, prefix, config});
   });
 };
 
-export { associations };
-
 /*
 The `models` option, becomes `permissions`, and can look like:
 
@@ -52,93 +28,45 @@ models: {
 
 */
 
-export default (server, model, { prefix, defaultConfig: config, models: permissions }) => {
+export default (server, model, {prefix, defaultConfig: config, models: permissions}) => {
   const modelName = model._singular;
-  const modelAttributes = Object.keys(model.attributes);
-  const modelAssociations = Object.keys(model.associations);
 
-  const attributeValidation = modelAttributes.reduce((params, attribute) => {
-    params[attribute] = joi.any();
-    return params;
-  }, {});
-
-  const associationValidation = {
-    include: joi.array().items(joi.string().valid(...modelAssociations)),
-  };
-
-  const scopes = Object.keys(model.options.scopes);
-
-  // if we don't have any permissions set, just create all the methods
   if (!permissions) {
-    createAll({
-      server,
-      model,
-      prefix,
-      config,
-      attributeValidation,
-      associationValidation,
-      scopes,
-    });
-  // if permissions are set, but we can't parse them, throw an error
-  } else if (!Array.isArray(permissions)) {
-    throw new Error('hapi-sequelize-crud: `models` property must be an array');
-  // if permissions are set, but the only thing we've got is a model name, there
-  // are no permissions to be set, so just create all methods and move on
-  } else if (permissions.includes(modelName)) {
-    createAll({
-      server,
-      model,
-      prefix,
-      config,
-      attributeValidation,
-      associationValidation,
-      scopes,
-    });
-  // if we've gotten here, we have complex permissions and need to set them
-  } else {
-    const permissionOptions = permissions.filter((permission) => {
-      return permission.model === modelName;
-    });
+    createAll({server, model, prefix, config});
+  }
+  else if (Array.isArray(permissions) && permissions.includes(modelName)) {
+    createAll({server, model, prefix, config});
+  }
+  else if (_.isPlainObject(permissions)) {
+    const permittedModels = Object.keys(permissions);
 
-    permissionOptions.forEach((permissionOption) => {
-      if (_.isPlainObject(permissionOption)) {
-        const permissionConfig = permissionOption.config || config;
-
-        if (permissionOption.methods) {
-          permissionOption.methods.forEach((method) => {
+    if (permissions[modelName] === true) {
+      createAll({server, model, prefix, config});
+    }
+    else if (permittedModels.includes(modelName)) {
+      if (Array.isArray(permissions[modelName])) {
+        permissions[modelName].forEach((method) => {
+          methods[method]({server, model, prefix, config});
+        });
+      }
+      else if (_.isPlainObject(permissions[modelName])) {
+        permissions[modelName].methods.forEach((method) => {
           methods[method]({
             server,
             model,
             prefix,
-              config: getConfigForMethod({
-                method,
-                attributeValidation,
-                associationValidation,
-                scopes,
-                config: permissionConfig,
-              }),
+            config: permissions[modelName].config || config,
           });
         });
-        } else {
-          createAll({
-            server,
-            model,
-            prefix,
-            attributeValidation,
-            associationValidation,
-            scopes,
-            config: permissionConfig,
-          });
       }
     }
-    });
   }
 };
 
-export const list = ({ server, model, prefix = '/', config }) => {
+export const list = ({server, model, prefix, config}) => {
   server.route({
     method: 'GET',
-    path: path.join(prefix, model._plural),
+    path: `${prefix}/${model._plural}`,
 
     @error
     async handler(request, reply) {
@@ -151,17 +79,17 @@ export const list = ({ server, model, prefix = '/', config }) => {
         where, include,
       });
 
-      reply(list.map((item) => item.toJSON()));
+      reply(list);
     },
 
     config,
   });
 };
 
-export const get = ({ server, model, prefix = '/', config }) => {
+export const get = ({server, model, prefix, config}) => {
   server.route({
     method: 'GET',
-    path: path.join(prefix, model._singular, '{id?}'),
+    path: `${prefix}/${model._singular}/{id?}`,
 
     @error
     async handler(request, reply) {
@@ -170,58 +98,68 @@ export const get = ({ server, model, prefix = '/', config }) => {
       const { id } = request.params;
       if (id) where[model.primaryKeyField] = id;
 
-      if (include instanceof Error) return void reply(include);
-
       const instance = await model.findOne({ where, include });
 
       if (!instance) return void reply(notFound(`${id} not found.`));
 
-      reply(instance.toJSON());
+      reply(instance);
     },
-    config,
+    config: _.defaultsDeep({
+      validate: {
+        params: joi.object().keys({
+          id: joi.any(),
+        }),
+      },
+    }, config),
   });
 };
 
-export const scope = ({ server, model, prefix = '/', config }) => {
+export const scope = ({server, model, prefix, config}) => {
+  const scopes = Object.keys(model.options.scopes);
+
   server.route({
     method: 'GET',
-    path: path.join(prefix, model._plural, '{scope}'),
+    path: `${prefix}/${model._plural}/{scope}`,
 
     @error
     async handler(request, reply) {
       const include = parseInclude(request);
       const where = parseWhere(request);
 
-      if (include instanceof Error) return void reply(include);
-
       const list = await model.scope(request.params.scope).findAll({ include, where });
 
-      reply(list.map((item) => item.toJSON()));
+      reply(list);
     },
-    config,
+    config: _.defaultsDeep({
+      validate: {
+        params: joi.object().keys({
+          scope: joi.string().valid(...scopes),
+        }),
+      },
+    }, config),
   });
 };
 
-export const create = ({ server, model, prefix = '/', config }) => {
+export const create = ({server, model, prefix, config}) => {
   server.route({
     method: 'POST',
-    path: path.join(prefix, model._singular),
+    path: `${prefix}/${model._singular}`,
 
     @error
     async handler(request, reply) {
       const instance = await model.create(request.payload);
 
-      reply(instance.toJSON());
+      reply(instance);
     },
 
     config,
   });
 };
 
-export const destroy = ({ server, model, prefix = '/', config }) => {
+export const destroy = ({server, model, prefix, config}) => {
   server.route({
     method: 'DELETE',
-    path: path.join(prefix, model._singular, '{id?}'),
+    path: `${prefix}/${model._singular}/{id?}`,
 
     @error
     async handler(request, reply) {
@@ -232,18 +170,17 @@ export const destroy = ({ server, model, prefix = '/', config }) => {
 
       await Promise.all(list.map(instance => instance.destroy()));
 
-      const listAsJSON = list.map((item) => item.toJSON());
-      reply(listAsJSON.length === 1 ? listAsJSON[0] : listAsJSON);
+      reply(list.length === 1 ? list[0] : list);
     },
 
     config,
   });
 };
 
-export const destroyAll = ({ server, model, prefix = '/', config }) => {
+export const destroyAll = ({server, model, prefix, config}) => {
   server.route({
     method: 'DELETE',
-    path: path.join(prefix, model._plural),
+    path: `${prefix}/${model._plural}`,
 
     @error
     async handler(request, reply) {
@@ -253,58 +190,73 @@ export const destroyAll = ({ server, model, prefix = '/', config }) => {
 
       await Promise.all(list.map(instance => instance.destroy()));
 
-      const listAsJSON = list.map((item) => item.toJSON());
-      reply(listAsJSON.length === 1 ? listAsJSON[0] : listAsJSON);
+      reply(list.length === 1 ? list[0] : list);
     },
 
     config,
   });
 };
 
-export const destroyScope = ({ server, model, prefix = '/', config }) => {
+export const destroyScope = ({server, model, prefix, config}) => {
+  const scopes = Object.keys(model.options.scopes);
+
   server.route({
     method: 'DELETE',
-    path: path.join(prefix, model._plural, '{scope}'),
+    path: `${prefix}/${model._plural}/{scope}`,
 
     @error
     async handler(request, reply) {
       const include = parseInclude(request);
       const where = parseWhere(request);
 
-      if (include instanceof Error) return void reply(include);
-
       const list = await model.scope(request.params.scope).findAll({ include, where });
 
       await Promise.all(list.map(instance => instance.destroy()));
 
-      const listAsJSON = list.map((item) => item.toJSON());
-      reply(listAsJSON.length === 1 ? listAsJSON[0] : listAsJSON);
+      reply(list);
     },
-    config,
+    config: _.defaultsDeep({
+      validate: {
+        params: joi.object().keys({
+          scope: joi.string().valid(...scopes),
+        }),
+      },
+    }, config),
   });
 };
 
-export const update = ({ server, model, prefix = '/', config }) => {
+export const update = ({server, model, prefix, config}) => {
   server.route({
     method: 'PUT',
-    path: path.join(prefix, model._singular, '{id}'),
+    path: `${prefix}/${model._singular}/{id}`,
 
     @error
     async handler(request, reply) {
       const { id } = request.params;
-      const instance = await model.findById(id);
+      const instance = await model.findOne({
+        where: {
+          id,
+        },
+      });
 
       if (!instance) return void reply(notFound(`${id} not found.`));
 
       await instance.update(request.payload);
 
-      reply(instance.toJSON());
+      reply(instance);
     },
 
-    config,
+    config: _.defaultsDeep({
+      validate: {
+        payload: joi.object().required(),
+      },
+    }, config),
   });
 };
 
+import * as associations from './associations/index';
+export { associations };
+
 const methods = {
   list, get, scope, create, destroy, destroyAll, destroyScope, update,
 };

src/crud.test.js

@@ -1,157 +0,0 @@
-import test from 'ava';
-import { list } from './crud.js';
-import { stub } from 'sinon';
-import uniqueId from 'lodash/uniqueId.js';
-import 'sinon-bluebird';
-
-const METHODS = {
-  GET: 'GET',
-};
-
-test.beforeEach('setup server', (t) => {
-  t.context.server = {
-    route: stub(),
-  };
-});
-
-const makeModel = () => {
-  const id = uniqueId();
-  return {
-    findAll: stub(),
-    _plural: 'models',
-    _singular: 'model',
-    toJSON: () => ({ id }),
-    id,
-  };
-};
-
-test.beforeEach('setup model', (t) => {
-  t.context.model = makeModel();
-});
-
-test.beforeEach('setup models', (t) => {
-  t.context.models = [t.context.model, makeModel()];
-});
-
-test.beforeEach('setup request stub', (t) => {
-  t.context.request = {
-    query: {},
-    payload: {},
-    models: [t.context.model],
-  };
-});
-
-test.beforeEach('setup reply stub', (t) => {
-  t.context.reply = stub();
-});
-
-test('crud#list without prefix', (t) => {
-  const { server, model } = t.context;
-
-  list({ server, model });
-  const { path } = server.route.args[0][0];
-
-  t.falsy(
-    path.includes('undefined'),
-    'correctly sets the path without a prefix defined',
-  );
-
-  t.is(
-    path,
-    `/${model._plural}`,
-    'the path sets to the plural model'
-  );
-});
-
-test('crud#list with prefix', (t) => {
-  const { server, model } = t.context;
-  const prefix = '/v1';
-
-  list({ server, model, prefix });
-  const { path } = server.route.args[0][0];
-
-  t.is(
-    path,
-    `${prefix}/${model._plural}`,
-    'the path sets to the plural model with the prefix'
-  );
-});
-
-test('crud#list method', (t) => {
-  const { server, model } = t.context;
-
-  list({ server, model });
-  const { method } = server.route.args[0][0];
-
-  t.is(
-    method,
-    METHODS.GET,
-    `sets the method to ${METHODS.GET}`
-  );
-});
-
-test('crud#list config', (t) => {
-  const { server, model } = t.context;
-  const userConfig = {};
-
-  list({ server, model, config: userConfig });
-  const { config } = server.route.args[0][0];
-
-  t.is(
-    config,
-    userConfig,
-    'sets the user config'
-  );
-});
-
-test('crud#list handler', async (t) => {
-  const { server, model, request, reply, models } = t.context;
-
-  list({ server, model });
-  const { handler } = server.route.args[0][0];
-  model.findAll.resolves(models);
-
-  try {
-    await handler(request, reply);
-  } catch (e) {
-    t.ifError(e, 'does not error while handling');
-  } finally {
-    t.pass('does not error while handling');
-  }
-
-  t.truthy(
-    reply.calledOnce
-    , 'calls reply only once'
-  );
-
-  const response = reply.args[0][0];
-
-  t.deepEqual(
-    response,
-    models.map(({ id }) => ({ id })),
-    'responds with the list of models'
-  );
-});
-
-test('crud#list handler if parseInclude errors', async (t) => {
-  const { server, model, request, reply } = t.context;
-  // we _want_ the error
-  delete request.models;
-
-  list({ server, model });
-  const { handler } = server.route.args[0][0];
-
-  await handler(request, reply);
-
-  t.truthy(
-    reply.calledOnce
-    , 'calls reply only once'
-  );
-
-  const response = reply.args[0][0];
-
-  t.truthy(
-    response.isBoom,
-    'responds with a Boom error'
-  );
-});

src/error.js

@@ -1,5 +1,3 @@
-import Boom from 'boom';
-
 export default (target, key, descriptor) => {
   const fn = descriptor.value;
 
@@ -7,60 +5,9 @@ export default (target, key, descriptor) => {
     try {
       await fn(request, reply);
     } catch (e) {
-      if (e.original) {
-        const { code, detail, hint } = e.original;
-        let error;
-
-        // pg error codes https://www.postgresql.org/docs/9.5/static/errcodes-appendix.html
-        if (code && (code.startsWith('22') || code.startsWith('23'))) {
-          error = Boom.wrap(e, 406);
-        } else if (code && (code.startsWith('42'))) {
-          error = Boom.wrap(e, 422);
-        // TODO: we could get better at parse postgres error codes
-        } else {
-          // use a 502 error code since the issue is upstream with postgres, not
-          // this server
-          error = Boom.wrap(e, 502);
-        }
-
-        // detail tends to be more specific information. So, if we have it, use.
-        if (detail) {
-          error.message += `: ${detail}`;
-          error.reformat();
-        }
-
-        // hint might provide useful information about how to fix the problem
-        if (hint) {
-          error.message += ` Hint: ${hint}`;
-          error.reformat();
-        }
-
-        reply(error);
-      } else if (!e.isBoom) {
-        const { message } = e;
-        let err;
-
-        if (e.name === 'SequelizeValidationError')
-          err = Boom.badData(message);
-        else if (e.name === 'SequelizeConnectionTimedOutError')
-          err = Boom.gatewayTimeout(message);
-        else if (e.name === 'SequelizeHostNotReachableError')
-          err = Boom.serverUnavailable(message);
-        else if (e.name === 'SequelizeUniqueConstraintError')
-          err = Boom.conflict(message);
-        else if (e.name === 'SequelizeForeignKeyConstraintError')
-          err = Boom.expectationFailed(message);
-        else if (e.name === 'SequelizeExclusionConstraintError')
-          err = Boom.expectationFailed(message);
-        else if (e.name === 'SequelizeConnectionError')
-          err = Boom.badGateway(message);
-        else err = Boom.badImplementation(message);
-
-        reply(err);
-      } else {
+      console.error(e);
       reply(e);
     }
-    }
   };
 
   return descriptor;

src/get-config-for-method.js

@@ -1,137 +0,0 @@
-import { set, get } from 'lodash';
-import joi from 'joi';
-
-// if the custom validation is a joi object we need to concat
-// else, assume it's an plain object and we can just add it in with .keys
-const concatToJoiObject = (joi, candidate) => {
-  if (!candidate) return joi;
-  else if (candidate.isJoi) return joi.concat(candidate);
-  else return joi.keys(candidate);
-};
-
-
-export const sequelizeOperators = {
-  $and: joi.any(),
-  $or: joi.any(),
-  $gt: joi.any(),
-  $gte: joi.any(),
-  $lt: joi.any(),
-  $lte: joi.any(),
-  $ne: joi.any(),
-  $eq: joi.any(),
-  $not: joi.any(),
-  $between: joi.any(),
-  $notBetween: joi.any(),
-  $in: joi.any(),
-  $notIn: joi.any(),
-  $like: joi.any(),
-  $notLike: joi.any(),
-  $iLike: joi.any(),
-  $notILike: joi.any(),
-  $overlap: joi.any(),
-  $contains: joi.any(),
-  $contained: joi.any(),
-  $any: joi.any(),
-  $col: joi.any(),
-};
-
-export const whereMethods = [
-  'list',
-  'get',
-  'scope',
-  'destroy',
-  'destoryScope',
-  'destroyAll',
-];
-
-export const includeMethods = [
-  'list',
-  'get',
-  'scope',
-  'destoryScope',
-];
-
-export const payloadMethods = [
-  'create',
-  'update',
-];
-
-export const scopeParamsMethods = [
-  'destroyScope',
-  'scope',
-];
-
-export const idParamsMethods = [
-  'get',
-  'update',
-];
-
-export default ({
-  method, attributeValidation, associationValidation, scopes = [], config = {},
-}) => {
-  const hasWhere = whereMethods.includes(method);
-  const hasInclude = includeMethods.includes(method);
-  const hasPayload = payloadMethods.includes(method);
-  const hasScopeParams = scopeParamsMethods.includes(method);
-  const hasIdParams = idParamsMethods.includes(method);
-  // clone the config so we don't modify it on multiple passes.
-  let methodConfig = { ...config, validate: { ...config.validate } };
-
-  if (hasWhere) {
-    const query = concatToJoiObject(joi.object()
-      .keys({
-        ...attributeValidation,
-        ...sequelizeOperators,
-      }),
-      get(methodConfig, 'validate.query')
-    );
-
-    methodConfig = set(methodConfig, 'validate.query', query);
-  }
-
-  if (hasInclude) {
-    const query = concatToJoiObject(joi.object()
-      .keys({
-        ...associationValidation,
-      }),
-      get(methodConfig, 'validate.query')
-    );
-
-    methodConfig = set(methodConfig, 'validate.query', query);
-  }
-
-  if (hasPayload) {
-    const payload = concatToJoiObject(joi.object()
-      .keys({
-        ...attributeValidation,
-      }),
-      get(methodConfig, 'validate.payload')
-    );
-
-    methodConfig = set(methodConfig, 'validate.payload', payload);
-  }
-
-  if (hasScopeParams) {
-    const params = concatToJoiObject(joi.object()
-      .keys({
-        scope: joi.string().valid(...scopes),
-      }),
-      get(methodConfig, 'validate.params')
-    );
-
-    methodConfig = set(methodConfig, 'validate.params', params);
-  }
-
-  if (hasIdParams) {
-    const params = concatToJoiObject(joi.object()
-      .keys({
-        id: joi.any(),
-      }),
-      get(methodConfig, 'validate.params')
-    );
-
-    methodConfig = set(methodConfig, 'validate.params', params);
-  }
-
-  return methodConfig;
-};

src/get-config-for-method.test.js

@@ -1,484 +0,0 @@
-import test from 'ava';
-import joi from 'joi';
-import
-  getConfigForMethod, {
-  whereMethods,
-  includeMethods,
-  payloadMethods,
-  scopeParamsMethods,
-  idParamsMethods,
-  sequelizeOperators,
-} from './get-config-for-method.js';
-
-test.beforeEach((t) => {
-  t.context.models = ['MyModel'];
-
-  t.context.scopes = ['aScope'];
-
-  t.context.attributeValidation = {
-    myKey: joi.any(),
-  };
-
-  t.context.associationValidation = {
-    include: joi.array().items(joi.string().valid(t.context.models)),
-  };
-
-  t.context.config = {
-    cors: {},
-  };
-});
-
-test('validate.query seqeulizeOperators', (t) => {
-  whereMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({ method });
-    const { query } = configForMethod.validate;
-
-    t.truthy(
-      query,
-      `applies query validation for ${method}`
-    );
-
-    Object.keys(sequelizeOperators).forEach((operator) => {
-      t.ifError(
-        query.validate({ [operator]: true }).error
-        , `applies sequelize operator "${operator}" in validate.where for ${method}`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('validate.query attributeValidation', (t) => {
-  const { attributeValidation } = t.context;
-
-  whereMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({ method, attributeValidation });
-    const { query } = configForMethod.validate;
-
-    Object.keys(attributeValidation).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies attributeValidation (${key}) to validate.query`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('query attributeValidation w/ config as plain object', (t) => {
-  const { attributeValidation } = t.context;
-  const config = {
-    validate: {
-      query: {
-        aKey: joi.boolean(),
-      },
-    },
-  };
-
-  whereMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      attributeValidation,
-      config,
-    });
-    const { query } = configForMethod.validate;
-
-    const keys = [
-      ...Object.keys(attributeValidation),
-      ...Object.keys(config.validate.query),
-    ];
-
-    keys.forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('query attributeValidation w/ config as joi object', (t) => {
-  const { attributeValidation } = t.context;
-  const queryKeys = {
-    aKey: joi.boolean(),
-  };
-  const config = {
-    validate: {
-      query: joi.object().keys(queryKeys),
-    },
-  };
-
-  whereMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      attributeValidation,
-      config,
-    });
-    const { query } = configForMethod.validate;
-
-    const keys = [
-      ...Object.keys(attributeValidation),
-      ...Object.keys(queryKeys),
-    ];
-
-    keys.forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('validate.query associationValidation', (t) => {
-  const { attributeValidation, associationValidation, models } = t.context;
-
-  includeMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      attributeValidation,
-      associationValidation,
-    });
-    const { query } = configForMethod.validate;
-
-    Object.keys(attributeValidation).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies attributeValidation (${key}) to validate.query when include should be applied`
-      );
-    });
-
-    Object.keys(associationValidation).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: models }).error
-        , `applies associationValidation (${key}) to validate.query when include should be applied`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('query associationValidation w/ config as plain object', (t) => {
-  const { associationValidation, models } = t.context;
-  const config = {
-    validate: {
-      query: {
-        aKey: joi.boolean(),
-      },
-    },
-  };
-
-  includeMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      associationValidation,
-      config,
-    });
-    const { query } = configForMethod.validate;
-
-    Object.keys(associationValidation).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: models }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    Object.keys(config.validate.query).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('query associationValidation w/ config as joi object', (t) => {
-  const { associationValidation, models } = t.context;
-  const queryKeys = {
-    aKey: joi.boolean(),
-  };
-  const config = {
-    validate: {
-      query: joi.object().keys(queryKeys),
-    },
-  };
-
-  includeMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      associationValidation,
-      config,
-    });
-    const { query } = configForMethod.validate;
-
-    Object.keys(associationValidation).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: models }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    Object.keys(queryKeys).forEach((key) => {
-      t.ifError(
-        query.validate({ [key]: true }).error
-        , `applies ${key} to validate.query`
-      );
-    });
-
-    t.truthy(
-      query.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('validate.payload associationValidation', (t) => {
-  const { attributeValidation } = t.context;
-
-  payloadMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({ method, attributeValidation });
-    const { payload } = configForMethod.validate;
-
-    Object.keys(attributeValidation).forEach((key) => {
-      t.ifError(
-        payload.validate({ [key]: true }).error
-        , `applies attributeValidation (${key}) to validate.payload`
-      );
-    });
-
-    t.truthy(
-      payload.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('payload attributeValidation w/ config as plain object', (t) => {
-  const { attributeValidation } = t.context;
-  const config = {
-    validate: {
-      payload: {
-        aKey: joi.boolean(),
-      },
-    },
-  };
-
-  payloadMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      attributeValidation,
-      config,
-    });
-    const { payload } = configForMethod.validate;
-
-    const keys = [
-      ...Object.keys(attributeValidation),
-      ...Object.keys(config.validate.payload),
-    ];
-
-    keys.forEach((key) => {
-      t.ifError(
-        payload.validate({ [key]: true }).error
-        , `applies ${key} to validate.payload`
-      );
-    });
-
-    t.truthy(
-      payload.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('payload attributeValidation w/ config as joi object', (t) => {
-  const { attributeValidation } = t.context;
-  const payloadKeys = {
-    aKey: joi.boolean(),
-  };
-  const config = {
-    validate: {
-      payload: joi.object().keys(payloadKeys),
-    },
-  };
-
-  payloadMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      attributeValidation,
-      config,
-    });
-    const { payload } = configForMethod.validate;
-
-    const keys = [
-      ...Object.keys(attributeValidation),
-      ...Object.keys(payloadKeys),
-    ];
-
-    keys.forEach((key) => {
-      t.ifError(
-        payload.validate({ [key]: true }).error
-        , `applies ${key} to validate.payload`
-      );
-    });
-
-    t.truthy(
-      payload.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('validate.params scopeParamsMethods', (t) => {
-  const { scopes } = t.context;
-
-  scopeParamsMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({ method, scopes });
-    const { params } = configForMethod.validate;
-
-    scopes.forEach((key) => {
-      t.ifError(
-        params.validate({ scope: key }).error
-        , `applies "scope: ${key}" to validate.params`
-      );
-    });
-
-    t.truthy(
-      params.validate({ scope: 'notAthing' }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('params scopeParamsMethods w/ config as plain object', (t) => {
-  const { scopes } = t.context;
-  const config = {
-    validate: {
-      params: {
-        aKey: joi.boolean(),
-      },
-    },
-  };
-
-  scopeParamsMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      scopes,
-      config,
-    });
-    const { params } = configForMethod.validate;
-
-    scopes.forEach((key) => {
-      t.ifError(
-        params.validate({ scope: key }).error
-        , `applies "scope: ${key}" to validate.params`
-      );
-    });
-
-    Object.keys(config.validate.params).forEach((key) => {
-      t.ifError(
-        params.validate({ [key]: true }).error
-        , `applies ${key} to validate.params`
-      );
-    });
-
-    t.truthy(
-      params.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-test('params scopeParamsMethods w/ config as joi object', (t) => {
-  const { scopes } = t.context;
-  const paramsKeys = {
-    aKey: joi.boolean(),
-  };
-  const config = {
-    validate: {
-      params: joi.object().keys(paramsKeys),
-    },
-  };
-
-  scopeParamsMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({
-      method,
-      scopes,
-      config,
-    });
-    const { params } = configForMethod.validate;
-
-    scopes.forEach((key) => {
-      t.ifError(
-        params.validate({ scope: key }).error
-        , `applies "scope: ${key}" to validate.params`
-      );
-    });
-
-    Object.keys(paramsKeys).forEach((key) => {
-      t.ifError(
-        params.validate({ [key]: true }).error
-        , `applies ${key} to validate.params`
-      );
-    });
-
-    t.truthy(
-      params.validate({ notAThing: true }).error
-      , 'errors on a non-valid key'
-    );
-  });
-});
-
-
-test('validate.payload idParamsMethods', (t) => {
-  idParamsMethods.forEach((method) => {
-    const configForMethod = getConfigForMethod({ method });
-    const { params } = configForMethod.validate;
-
-    t.ifError(
-      params.validate({ id: 'aThing' }).error
-      , 'applies id to validate.params'
-    );
-  });
-});
-
-test('does not modify initial config on multiple passes', (t) => {
-  const { config } = t.context;
-  const originalConfig = { ...config };
-
-  whereMethods.forEach((method) => {
-    getConfigForMethod({ method, ...t.context });
-  });
-
-  t.deepEqual(
-    config
-    , originalConfig
-    , 'does not modify the original config object'
-  );
-});

src/index.js

@@ -1,5 +1,5 @@
 if (!global._babelPolyfill) {
-  require('babel-polyfill');
+  require('babel/polyfill');
 }
 
 import crud, { associations } from './crud';

src/utils.js

@@ -1,5 +1,4 @@
 import { omit, identity } from 'lodash';
-import { notImplemented } from 'boom';
 
 export const parseInclude = request => {
   const include = Array.isArray(request.query.include) ? request.query.include
@@ -9,7 +8,7 @@ export const parseInclude = request => {
   const noRequestModels = !request.models;
 
   if (noGetDb && noRequestModels) {
-    return notImplemented('`request.getDb` or `request.models` are not defined.'
+    return new Error('`request.getDb` or `request.models` are not defined.'
                    + 'Be sure to load hapi-sequelize before hapi-sequelize-crud.');
   }