Merge branch 'master' into patch-1

Author: pmcnr-hx

.travis.yml

@@ -8,6 +8,8 @@ node_js:
 services:
   - mysql
   - postgresql
+addons:
+  postgresql: "9.4"
 script: npm run ci
 notifications:
   email: false

CHANGELOG.md

@@ -1,9 +1,12 @@
-- 2017-09-25 - v2.0.0-alpha
-- 2017-09-25 -  :warning: GraphQL support is incomplete in this alpha release
-- 2017-09-25 - Bump all dependencies
-- 2017-09-25 - Support Node.js 8
-- 2017-09-25 - Only Node.js >= 4.5 is now supported
-- 2017-09-25 - Support latest `jsonapi-server`
+- 2017-09-27 - v2.1.0
+- 2017-09-27 - Migrate to Sequelize v4
+- 2017-09-27 - Use native Array support for PostgreSQL
+- 2017-09-26 - v2.0.0
+- 2017-09-26 - Support Node.js 8
+- 2017-09-26 - Only Node.js >= 4.5 is now supported
+- 2017-09-26 - Support latest `jsonapi-server`
+- 2017-09-26 - Bug fix: correctly support arrays
+- 2017-09-26 - Bug fix: properly fix table names
 - 2016-08-09 - v1.2.8
 - 2016-08-09 - Update `sequelize` dependency to latest version
 - 2016-08-09 - Optimised searches filtered by related resource

README.md

@@ -1,5 +1,3 @@
-### :warning: !!! GraphQL support is incomplete for the current 2.0.0-alpha release !!! :warning:
-
 [![Coverage Status](https://coveralls.io/repos/holidayextras/jsonapi-store-relationaldb/badge.svg?branch=master&service=github)](https://coveralls.io/github/holidayextras/jsonapi-store-relationaldb?branch=master)
 [![Build Status](https://travis-ci.org/holidayextras/jsonapi-store-relationaldb.svg?branch=master)](https://travis-ci.org/holidayextras/jsonapi-store-relationaldb)
 [![npm version](https://badge.fury.io/js/jsonapi-store-relationaldb.svg)](http://badge.fury.io/js/jsonapi-store-relationaldb)
@@ -18,8 +16,6 @@ This project conforms to the specification laid out in the [jsonapi-server handl
  * Postgres
  * MySQL
  * MariaDB
- * SQLite
- * Microsoft SQL Server
 
 ### Usage
 
@@ -30,6 +26,9 @@ jsonApi.define({
   resource: "comments",
   handlers: new RelationalDbStore({
     dialect: "mysql",
+    dialectOptions: {
+      supportBigNumbers: true
+    },
     host: "localhost",
     port: 3306,
     database: "jsonapi", // If not provided, defaults to the name of the resource
@@ -64,6 +63,14 @@ When deploying schema changes, you'll need to correct your database schema - dat
 
 When changing columns in a production database, a typical approach might be to create a new table that is a clone of the table in production, copy all data from the production table into the new table, run an ALTER-TABLE command on the new table to adjust the columns (this may take a while and will lock the table), then run a RENAME-TABLES to swap the production table out for the new one.
 
+**Note:** When populating database tables, you can use the `force` config option to DROP and CREATE tables. This is helpful in development stage, when your data doesn't matter and you want your Tables schemas to change according to the DAOs without having to manually write migrations.
+
+```js
+(new RelationalDbStore()).populate({force: true}, () => {
+  //tables dropped and created
+})
+```
+
 ### Gotchas
 
 Relational databases don't differentiate between `undefined` and `null` values. `Joi` does differentiate between `undefined` and `null` values. Some `undefined` properties will pass validation, whilst `null` properties may not. For example, the default articles resource contains a `created` attribute of type `"date"` - this won't pass validation with a `null` value, so the Joi schema will need tweaking.

lib/modelGenerators/default.js

@@ -0,0 +1,52 @@
+var DataTypes = require('sequelize').DataTypes
+
+exports.joiSchemaToSequelizeModel = function(resourceName, joiSchema) {
+  var model = {
+    id: { type: new DataTypes.STRING(38), primaryKey: true },
+    type: {
+      type: DataTypes.VIRTUAL, //We do not actually save this to DB, but API needs this
+      set: function (val) {
+        this.setDataValue('type', val)
+      },
+      get: function () {
+        return resourceName
+      }
+    },
+    meta: {
+      type: DataTypes.STRING,
+      get: function() {
+        var data = this.getDataValue("meta");
+        if (!data) return undefined;
+        return JSON.parse(data);
+      },
+      set: function(val) {
+        return this.setDataValue("meta", JSON.stringify(val));
+      }
+    }
+  };
+
+  Object.keys(joiSchema).forEach(function(attributeName) {
+    var attribute = joiSchema[attributeName];
+    if (attribute._type === "string") model[attributeName] = { type: DataTypes.TEXT, allowNull: true };
+    if (attribute._type === "date") model[attributeName] = { type: DataTypes.DATE, allowNull: true };
+    if (attribute._type === "number") model[attributeName] = { type: DataTypes.NUMERIC, allowNull: true };
+    if (attribute._type === "boolean") model[attributeName] = { type: DataTypes.BOOLEAN, allowNull: true };
+    if (attribute._type === "array") {
+      //Serialize array to ';'-separated string for most SQL dbs.
+      model[attributeName] = {
+        type: DataTypes.STRING,
+        allowNull: true,
+        get: function () {
+          var data = this.getDataValue(attributeName);
+          return data ? data.split(';') : []
+        },
+        set: function (val) {
+          this.setDataValue(attributeName, val.join(';'));
+        }
+      }
+
+    }
+  });
+
+  return model;
+};

lib/modelGenerators/postgres.js

@@ -0,0 +1,57 @@
+var DataTypes = require('sequelize').DataTypes
+
+exports.joiSchemaToSequelizeModel = function(resourceName, joiSchema) {
+  var model = {
+    id: { type: new DataTypes.STRING(38), primaryKey: true },
+    type: {
+      type: DataTypes.VIRTUAL, //We do not actually save this to DB, but API needs this
+      set: function (val) {
+        this.setDataValue('type', val)
+      },
+      get: function () {
+        return resourceName
+      }
+    },
+    meta: {
+      type: DataTypes.JSONB,
+      get: function() {
+        var data = this.getDataValue("meta");
+        if (!data) return undefined;
+        return data;
+      },
+      set: function(val) {
+        return this.setDataValue("meta", val);
+      }
+    }
+  };
+
+  Object.keys(joiSchema).forEach(function(attributeName) {
+    var attribute = joiSchema[attributeName];
+    if (attribute._type === "string") model[attributeName] = { type: DataTypes.TEXT, allowNull: true };
+    if (attribute._type === "date") model[attributeName] = { type: DataTypes.DATE, allowNull: true };
+    if (attribute._type === "number") {
+      if (typeof attribute._flags.precision !== "undefined") {
+        model[attributeName] = { type: DataTypes.NUMERIC(32, attribute._flags.precision), allowNull: true };
+      } else {
+        model[attributeName] = { type: DataTypes.NUMERIC, allowNull: true };
+      }
+    }
+    if (attribute._type === "boolean") model[attributeName] = { type: DataTypes.BOOLEAN, allowNull: true };
+    if (attribute._type === "array") {
+      //PostgreSQL has proper array support, so lets use that
+      switch (attribute._inner.items[0]._type) {
+        case "string": model[attributeName] = {type: DataTypes.ARRAY(DataTypes.STRING), allowNull: true}; break;
+        case "number": model[attributeName] = {type: DataTypes.ARRAY(DataTypes.NUMERIC), allowNull: true}; break;
+        case "boolean": model[attributeName] = {type: DataTypes.ARRAY(DataTypes.BOOLEAN), allowNull: true}; break;
+      }
+      model[attributeName].get = function () {
+        return this.getDataValue(attributeName) || []
+      }
+      model[attributeName].set = function (val) {
+        this.setDataValue(attributeName, val ? val : [])
+      }
+    }
+  });
+
+  return model;
+};

lib/sqlHandler.js

@@ -1,17 +1,18 @@
 "use strict";
 // http://docs.sequelizejs.com/en/latest/
 var Sequelize = require("sequelize");
+var DataTypes = Sequelize.DataTypes;
 var async = require("async");
 var crypto = require("crypto");
 var debug = require("debug")("jsonApi:store:relationaldb");
 var Joi = require("joi");
 var semver = require("semver");
-var _ = {
-  pick: require("lodash.pick"),
-  assign: require("lodash.assign"),
-  omit: require("lodash.omit")
-};
-  var util = require('util');
+var _ = require("lodash");
+var util = require('util');
+var modelGenerators = {
+  postgres: require('./modelGenerators/postgres'),
+  default: require('./modelGenerators/default')
+}
 
 var MIN_SERVER_VERSION = "1.10.0";
 
@@ -46,10 +47,16 @@ SqlStore.prototype.initialise = function(resourceConfig) {
   var database = self.config.database || resourceConfig.resource;
   var sequelizeArgs = [database, self.config.username, self.config.password, {
     dialect: self.config.dialect,
+    dialectOptions: self.config.dialectOptions,
     host: self.config.host,
     port: self.config.port,
+    storage: self.config.storage || ":memory:",
     logging: self.config.logging || require("debug")("jsonApi:store:relationaldb:sequelize"),
-    freezeTableName: true
+    define: {
+      // Set freezeTableName on all table definitions to prevent sequelize from pluralizing
+      // all table names by itself.
+      freezeTableName: true
+    }
   }];
 
   // To prevent too many open connections, we will store all Sequelize instances in a hash map.
@@ -61,8 +68,7 @@ SqlStore.prototype.initialise = function(resourceConfig) {
   var instances = SqlStore._sequelizeInstances;
 
   if (!instances[instanceId]) {
-    var sequelize = Object.create(Sequelize.prototype);
-    Sequelize.apply(sequelize, sequelizeArgs);
+    var sequelize = new (Function.prototype.bind.apply(Sequelize, [null].concat(sequelizeArgs)))();
     instances[instanceId] = sequelize;
   }
 
@@ -73,16 +79,21 @@ SqlStore.prototype.initialise = function(resourceConfig) {
   self.ready = true;
 };
 
-SqlStore.prototype.populate = function(callback) {
+SqlStore.prototype.populate = function(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
   var self = this;
 
   var tasks = [
     function(cb) {
-      self.baseModel.sync().asCallback(cb);
+      self.baseModel.sync(options).asCallback(cb);
     },
     function(cb) {
       async.eachSeries(self.relationArray, function(model, ecb) {
-        model.sync().asCallback(ecb);
+        model.sync(options).asCallback(ecb);
       }, cb);
     },
     function(cb) {
@@ -113,7 +124,19 @@ SqlStore.prototype._buildModels = function() {
   });
   relations = _.pick(self.resourceConfig.attributes, relations);
 
-  var modelAttributes = self._joiSchemaToSequelizeModel(localAttributes);
+  var modelAttributes = { };
+  switch (self.config.dialect) {
+    case 'postgres':
+      modelAttributes = modelGenerators.postgres.joiSchemaToSequelizeModel(
+        self.resourceConfig.resource,
+        localAttributes)
+      break;
+    default:
+      modelAttributes = modelGenerators.default.joiSchemaToSequelizeModel(
+        self.resourceConfig.resource,
+        localAttributes)
+  }
+
   self.baseModel = self.sequelize.define(self.resourceConfig.resource, modelAttributes, { timestamps: false });
 
   self.relations = { };
@@ -126,54 +149,26 @@ SqlStore.prototype._buildModels = function() {
   });
 };
 
-SqlStore.prototype._joiSchemaToSequelizeModel = function(joiSchema) {
-  var model = {
-    id: { type: new Sequelize.STRING(38), primaryKey: true },
-    type: Sequelize.STRING,
-    meta: {
-      type: Sequelize.STRING,
-      get: function() {
-        var data = this.getDataValue("meta");
-        if (!data) return undefined;
-        return JSON.parse(data);
-      },
-      set: function(val) {
-        return this.setDataValue("meta", JSON.stringify(val));
-      }
-    }
-  };
-
-  Object.keys(joiSchema).forEach(function(attributeName) {
-    var attribute = joiSchema[attributeName];
-    if (attribute._type === "string") model[attributeName] = { type: Sequelize.STRING, allowNull: true };
-    if (attribute._type === "date") model[attributeName] = { type: Sequelize.STRING, allowNull: true };
-    if (attribute._type === "number") model[attributeName] = { type: Sequelize.INTEGER, allowNull: true };
-    if (attribute._type === "boolean") model[attributeName] = { type: Sequelize.BOOLEAN, allowNull: true };
-  });
-
-  return model;
-};
-
 SqlStore.prototype._defineRelationModel = function(relationName, many) {
   var self = this;
 
   var modelName = self.resourceConfig.resource + "-" + relationName;
   var modelProperties = {
     uid: {
-      type: Sequelize.INTEGER,
+      type: DataTypes.INTEGER,
       primaryKey: true,
       autoIncrement: true
     },
     id: {
-      type: new Sequelize.STRING(38),
+      type: new DataTypes.STRING(38),
       allowNull: false
     },
     type: {
-      type: new Sequelize.STRING(38),
+      type: new DataTypes.STRING(38),
       allowNull: false
     },
     meta: {
-      type: Sequelize.STRING,
+      type: DataTypes.STRING,
       get: function() {
         var data = this.getDataValue("meta");
         if (!data) return undefined;