SQL Generation

.gitignore

@@ -3,3 +3,4 @@ node_modules
 coverage
 npm-debug.log
 .eslintrc*
+config.env

.istanbul.yml

@@ -0,0 +1,11 @@
+verbose: false
+instrumentation:
+  root: ./src
+  excludes: []
+  include-all-sources: true
+  check:
+    global:
+      branches   : 100
+      functions  : 100
+      lines      : 100
+      statements : 100

.travis.yml

@@ -2,5 +2,9 @@ language: node_js
 node_js:
   - "6"
 script: npm run coverage
+before_script:
+  - psql -c 'CREATE DATABASE travis_ci_test;' -U postgres
 after_script:
   - npm run codecov
+services:
+  - postgresql

README.md

@@ -86,3 +86,11 @@ a well-managed PostgreSQL cluster copes very well.
 > If you're still Curious or Worried about scaling PostgreSQL?
 see: https://www.citusdata.com
 > Want to model the network of people as a graph? https://github.com/cayleygraph/cayley
+
+## Running the Project
+
+For the tests to work you will need to have the url to a test database in a `config.env` file as followed:
+```
+TEST_DATABASE_URL=psql://localhost:5432/testdb
+```
+**Note** before tests are run the tables may be removed from the database so don't keep your family photos there.

examples/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var Hapi = require('hapi');
+var Abase = require('../lib/index.js');
+var server = new Hapi.Server();
+var config = require('./config.json');
+
+require('env2')('config.env');
+
+server.connection({ port: process.env.PORT || 8888 });
+
+server.register({
+  register: Abase, options: config
+}, function (err) {
+  if (err) {
+    throw err;
+  }
+
+  server.start(function () {
+    server.log('Server started');
+  });
+});

lib/add_default_values.js

@@ -1,25 +1,25 @@
+'use strict';
+
 /**
 * Initialse with the default values the schema if they are not defined Yet
 * Write schema in the file if the default values are added
 * @param {object} schema - the user schema object
 * @return {boolean} - any changes apply to the schema
 */
 var defaultSchema = {
-  email: {
-    type: 'email'
-  },
-  password: {
-    type: 'password'
-  }
+  email: { type: 'email' },
+  password: { type: 'password' }
 };
 
 module.exports = function (schema) {
   var anyChanges = false;
-  Object.keys(defaultSchema).forEach(function(field) {
-    if(!schema.hasOwnProperty(field)){
+
+  Object.keys(defaultSchema).forEach(function (field) {
+    if (!schema.hasOwnProperty(field)) {
       schema[field] = defaultSchema[field];
       anyChanges = true;
-    };
+    }
   });
+
   return anyChanges;
 };

lib/config_validator.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var Joi = require('joi');
+
+var mapObj = require('./create_table_map.js').mapObj;
+
+// non empty, alphanumeric, no leading number, less than 64
+var dbNameRegEx = /^[A-Za-z_]\w{0,62}$/;
+var fieldTypes = Object.keys(mapObj);
+
+var fieldSchema = Joi.object()
+  .keys({ type: Joi.any().valid(fieldTypes) })
+  .unknown()
+;
+var configSchema = Joi.object().keys({
+  table_name: Joi.string().regex(dbNameRegEx).required(), // eslint-disable-line
+  fields: Joi.object().pattern(dbNameRegEx, fieldSchema).required() // eslint-disable-line
+});
+
+module.exports = function (config) {
+  return Joi.assert(config, configSchema);
+};
+
+module.exports.dbNameRegEx = dbNameRegEx;

lib/create_table_map.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var mapObj = {
+  number: function (opts) {
+    return opts.integer ? 'BIGINT' : 'DOUBLE PRECISION';
+  },
+  string: function (opts) {
+    var length = opts.max || 80;
+
+    return 'VARCHAR(' + length + ')';
+  },
+  boolean: function () {
+    return 'BOOLEAN';
+  },
+  date: function (opts) {
+    return opts.timestamp ? 'TIMESTAMP' : 'DATE';
+  }
+};
+
+function mapper (name, type, options) {
+  var opts = options || {};
+
+  return name + ' ' + mapObj[type](opts);
+}
+
+module.exports = mapper;
+module.exports.mapObj = mapObj;

lib/db.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var sqlGen = require('./sql_gen.js');
+var configValidator = require('./config_validator.js');
+
+var methods = { init: function (client, config, _, cb) {
+  configValidator(config);
+
+  return client.query(sqlGen.init(config), cb);
+} };
+
+['select', 'update', 'delete', 'insert'].forEach(function (method) {
+  methods[method] = function (client, config, options, cb) {
+    var tableName = config.table_name;
+    var args = sqlGen[method](tableName, options).concat([cb]);
+
+    return client.query.apply(client, args);
+  };
+});
+
+module.exports = methods;

lib/index.js

@@ -1,28 +1,30 @@
+'use strict';
+
 var addDefaultValues = require('./add_default_values.js');
 var loadSchema = require('./load_schema.js');
 var updateSchema = require('./update_schema.js');
-var fs = require('fs');
 
 module.exports = function (server, options, next) {
   if (!options.hasOwnProperty('user_schema_path')) {
-    return next('Error: user_schema_path is not defined, please define a user_schema_path');
+    return next(new Error('user_schema_path is not defined'));
   }
 
-  loadSchema(options.user_schema_path, function(errorLoad, schema) {
+  return loadSchema(options.user_schema_path, function (errorLoad, schema) {
     if (errorLoad) {
       return next(errorLoad);
     }
 
-    if (addDefaultValues(schema)) {
-      updateSchema(options.user_schema_path, schema, function(errorUpdateSchema) {
-        return next(errorUpdateSchema);
-      });
-    } else {
+    if (!addDefaultValues(schema)) {
       return next();
     }
+
+    return updateSchema(
+      options.user_schema_path,
+      schema,
+      function (errorUpdateSchema) {
+        return next(errorUpdateSchema);
+      });
   });
 };
 
-module.exports.attributes = {
-  name: 'Abase'
-};
+module.exports.attributes = { name: 'Abase' };

lib/load_schema.js

@@ -1,20 +1,30 @@
+'use strict';
+
+var fs = require('fs');
+
 /**
-* load the shema user
+* load the schema user
 * @param {sting} schemaPath - the file path of the schema
 * @param {function} cb - callback with error and the schema object
+* @returns {void}
 */
-var fs = require('fs');
-
 module.exports = function (schemaPath, cb) {
   fs.readFile(schemaPath, function (err, data) {
+    var schema;
+
     if (err) {
       return cb('Error: sorry impossible to read the file at ' + schemaPath);
     }
+
     try {
-      var schema = JSON.parse(data);
+      schema = JSON.parse(data);
     } catch (parseError) {
-        return cb('Error: the schema user file contains unconventianal type, please make sure an schema object is defined');
+      return cb(
+        'Error: the schema user file contains unconventianal type,'
+        + 'please make sure an schema object is defined'
+      );
     }
-    return cb(undefined, schema);
+
+    return cb(null, schema);
   });
 };

lib/sql_gen.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var mapper = require('./create_table_map.js');
+var _ = require('./utils.js');
+
+
+function paramStr (columns, opts) {
+  var offset = (opts && opts.offset) || 0;
+  var assign = (opts && opts.assign) || false;
+
+  return columns.map(function (k, i) {
+    var suff = '$' + (1 + i + (offset || 0));
+    var pref = assign ? k + '=' : '';
+
+    return pref + suff;
+  });
+}
+
+
+function processWhere (where, query, values) {
+  var keys = Object.keys(where);
+  var conds = paramStr(keys, {
+    offset: values.length, assign: true
+  });
+  var vals = _.values(where, keys);
+
+  return {
+    query: query.concat('WHERE').concat(conds.join(', ')),
+    values: values.concat(vals)
+  };
+}
+
+
+exports.init = function init (config) {
+  var tableName = config.table_name;
+  var fields = config.fields;
+
+  var columns = Object.keys(fields).map(function (key) {
+    var type = fields[key].type;
+    var opts = _.except(['type'], fields[key]);
+
+    return mapper(key, type, opts);
+  });
+
+  return ['CREATE TABLE IF NOT EXISTS "' + tableName + '"']
+    .concat('(' + columns.join(', ') + ')')
+    .join(' ')
+    .trim();
+};
+
+
+exports.select = function select (tableName, options) {
+  var columns = options.select || ['*'];
+  var values = [];
+  var query = ['SELECT']
+    .concat(columns.join(', '))
+    .concat('FROM')
+    .concat('"' + tableName + '"');
+  var result;
+
+  if (options.where) {
+    result = processWhere(options.where, query, values);
+    query = result.query;
+    values = result.values;
+  }
+
+  query = query.join(' ').trim();
+
+  return [query, values];
+};
+
+
+exports.insert = function insert (tableName, options) {
+  var fields = options.fields || {};
+  var columns = Object.keys(fields);
+  var values = _.values(fields, columns);
+  var params = paramStr(columns);
+
+  var query = ['INSERT INTO "' + tableName + '"']
+    .concat('(' + columns.join(', ') + ')')
+    .concat('VALUES')
+    .concat('(' + params.join(', ') + ')')
+    .join(' ')
+    .trim();
+
+  return [query, values];
+};
+
+
+exports.update = function update (tableName, options) {
+  var fields = options.fields || {};
+  var columns = Object.keys(fields);
+  var conditions = paramStr(columns, { assign: true });
+  var values = _.values(fields, columns);
+
+  var query = ['UPDATE "' + tableName + '"']
+    .concat('SET')
+    .concat(conditions.join(', '));
+  var result;
+
+  if (options.where) {
+    result = processWhere(options.where, query, values);
+    query = result.query;
+    values = result.values;
+  }
+
+  query = query.join(' ').trim();
+
+  return [query, values];
+};
+
+
+exports.delete = function _delete (tableName, options) {
+  var query = ['DELETE FROM "' + tableName + '"'];
+  var values = [];
+  var result = processWhere(options.where, query, values);
+
+  query = result.query;
+  values = result.values;
+
+  query = query.join(' ').trim();
+
+  return [query, values];
+};

lib/update_schema.js

@@ -1,11 +1,14 @@
+'use strict';
+
+var fs = require('fs');
+
 /**
 * Update the schema json file
-* @param {string} user_schema_path, the path of the schema file
+* @param {string} userSchemaPath, the path of the schema file
 * @param {object} schema - the schema user object
 * @param {function} cb - callback with error
+* @returns {void}
 */
-
-var fs = require('fs');
-module.exports = function (user_schema_path, schema, cb) {
-  fs.writeFile(user_schema_path, JSON.stringify(schema), 'utf8', cb);
+module.exports = function (userSchemaPath, schema, cb) {
+  fs.writeFile(userSchemaPath, JSON.stringify(schema), 'utf8', cb);
 };