SQL Generation

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 .DS_Store
 coverage
+config.env

examples/index.js

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

lib/config_validator.js

@@ -0,0 +1,20 @@
+var Joi = require('joi');
+
+var mapObj = require('./create_table_map.js').mapObj;
+
+var fieldTypes = Object.keys(mapObj);
+var dbNameRegEx = /^[A-Za-z_]\w{0,62}$/;
+
+var configSchema = Joi.object().keys({
+  table_name: Joi.string().regex(dbNameRegEx).required(),
+  fields: Joi.object().pattern(
+    dbNameRegEx,
+    Joi.object().keys({type: Joi.any().valid(fieldTypes)})
+  ).required()
+});
+
+module.exports = function (config) {
+  return Joi.validate(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/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var pg = require('pg');
+
+exports.register = function (server, options, next) {
+
+  var dbUrl = process.env.DATABASE_URL;
+  server.app.pool = new pg.Pool(dbUrl);
+
+  server.route({
+    method: 'GET',
+    path: '/',
+    handler: function (request, reply) {
+      var select = 'select $1::text from information_schema.tables';
+
+      server.app.pool.query(select, ['table_name'], function(err, result) {
+        return reply(result);
+      });
+    }
+  });
+
+  server.app.pool.query('CREATE TABLE IF NOT EXISTS '
+  + '"' + options.tableName + '"'
+  + ' ('
+  + 'email varchar(80),'
+  + 'username varchar(80)'
+  + ')'
+  , function (err, result) {
+    console.log(err, result);
+  });
+};
+
+exports.register.attributes = {
+  pkg: {
+    name: 'Abase'
+  }
+};

lib/sql_gen.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var mapper = require('./create_table_map.js');
+
+exports.init = function init (config) {
+  var tableName = config.table_name;
+  var fields = config.fields;
+  var query = 'CREATE TABLE IF NOT EXISTS "' + tableName + '" ';
+
+  var columns = Object.keys(fields).map(function (key) {
+    var type = fields[key].type;
+    var opts = fields[key];
+
+    return mapper(key, type, opts);
+  });
+
+  query += '(' + columns.join(', ') + ')';
+
+  return query;
+};

package.json

@@ -16,6 +16,7 @@
   "homepage": "https://github.com/dwyl/abase#readme",
   "devDependencies": {
     "eslint": "^3.5.0",
+    "hapi": "^15.0.3",
     "istanbul": "^0.4.5",
     "pre-commit": "^1.1.3",
     "tape": "^4.6.0"
@@ -29,5 +30,9 @@
   "pre-commit": [
     "lint",
     "test"
-  ]
+  ],
+  "dependencies": {
+    "env2": "^2.1.1",
+    "pg": "^6.1.0"
+  }
 }

test/config_validator.test.js

@@ -0,0 +1,55 @@
+var test = require('tape');
+
+var validator = require('../lib/config_validator.js');
+var dbNameRegEx = validator.dbNameRegEx;
+
+test('config validator', function (t) {
+  t.ok(
+    validator({ fields: {} }).error,
+    'error if no table_name property'
+  );
+  t.ok(
+    validator({ table_name: 'test' }).error,
+    'error if no fields property'
+  );
+  t.ok(
+    validator({ table_name: '2test', fields: {} }).error,
+    'error if table name doesn\t pass db name regex'
+  );
+  t.ok(
+    validator({ table_name: '2test', fields: {} }).error,
+    'error if table name doesn\t pass db name regex'
+  );
+  t.ok(
+    validator({
+      table_name: 'test',
+      fields: {'2field': {type: 'string'}}
+    }).error,
+    'error if field name doesn\'t pass db name regex'
+  );
+
+  t.end();
+});
+
+test('dbNameRegEx', function (t) {
+  t.ok(
+    dbNameRegEx.exec('_a1pha_Numer1c'),
+    'alpha numeric keys allowed only'
+  );
+  t.notOk(
+    dbNameRegEx.exec('no£way'),
+    'no other characters allowed'
+  );
+  t.notOk(
+    dbNameRegEx.exec('3Numer1c'),
+    'must only start with a _ or letter'
+  );
+  t.notOk(
+    dbNameRegEx.exec(
+      '_morethan63characters_morethan63characters_morethan63characters_'
+    ),
+    '63 character limit for field names'
+  );
+
+  t.end();
+});

test/create_table_map.test.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var test = require('tape');
+
+var mapper = require('../lib/create_table_map.js');
+
+var mapObj = mapper.mapObj;
+
+test('Boolean type', function (t) {
+  t.equal(
+    mapObj['boolean']({}),
+    'BOOLEAN',
+    'boolean type: default'
+  );
+  t.end();
+});
+
+test('Date type', function (t) {
+  t.equal(
+    mapObj['date']({}),
+    'DATE',
+    'date type: default'
+  );
+  t.equal(
+    mapObj['date']({ timestamp: true }),
+    'TIMESTAMP',
+    'date type: timestamp'
+  );
+  t.end();
+});
+
+test('Number type', function (t) {
+  t.equal(
+    mapObj['number']({}),
+    'DOUBLE PRECISION',
+    'number type: default'
+  );
+  t.equal(
+    mapObj['number']({ integer: true }),
+    'BIGINT',
+    'number type: integer'
+  );
+  t.end();
+});
+
+test('String type', function (t) {
+  t.equal(
+    mapObj['string']({}),
+    'VARCHAR(80)',
+    'string type: default'
+  );
+  t.equal(
+    mapObj['string']({ max: 12 }),
+    'VARCHAR(12)',
+    'string type: specifies length'
+  );
+  t.end();
+});
+
+test('Create Table Mapper Function', function (t) {
+  t.equal(
+    mapper('field', 'string', { max: 140 }),
+    'field VARCHAR(140)',
+    'name added to sql query and options passed through'
+  );
+  t.end();
+});
+
+test('Create Table Mapper Function w/ no options', function (t) {
+  t.equal(
+    mapper('field', 'string'),
+    'field VARCHAR(80)',
+    'name added to sql query and default options used'
+  );
+  t.end();
+});

test/sql_gen.test.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var tape = require('tape');
+var sqlGen = require('../lib/sql_gen.js');
+
+var schema = {
+  table_name: 'user_data',
+  fields: {
+    email: {
+      type: 'string',
+      email: true
+    },
+    username: {
+      type: 'string',
+      min: 3,
+      max: 20
+    },
+    dob: {
+      type: 'date'
+    }
+  }
+};
+
+tape('::init should throw on empty or invalid input', function (t) {
+  t.throws(function () {
+    sqlGen.init();
+  });
+  t.end();
+});
+
+tape('::init should generate SQL to create a table if none exists', function (t) {
+  var query = sqlGen.init(schema);
+
+  t.equal(
+    query,
+    'CREATE TABLE IF NOT EXISTS "user_data" ('
+    + 'email VARCHAR(80), '
+    + 'username VARCHAR(20), '
+    + 'dob DATE'
+    + ')',
+    'Create table query generation from config object'
+  );
+  t.end();
+});
+
+// tape('::update should generate empty string on invalid input', function () {});
+
+// tape('::update should generate SQL to update a column in a table', function () {});