[WIP] Add migration support for sqlite, better validation

.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+  - "stable"
+cache:
+  directories:
+    - "node_modules"
+script:
+  - npm test

README.md

@@ -1,5 +1,14 @@
 # JSON to Knex
 
+
+```bash
+npm install json-to-knex
+j2k init  # creates json-migrations folder, .jtkconfig file
+# write your schema
+j2k migrate
+# generates your tables for you!
+```
+
 ## What it does
 
 JSON to Knex dynamically creates tables by parsing a JSON structure into a series of chained knexjs functions using the input you specify.

cli/applyNextMigration.js

@@ -0,0 +1,8 @@
+const fs = require("fs");
+const migrator = require("../lib/migrations");
+const dbManager = require("../lib/db-manager");
+// check for dbSchema.json
+
+(async () => {
+  // stub
+})();

cli/init.js

@@ -0,0 +1,8 @@
+const fs = require("fs");
+const migrator = require("../lib/migrations");
+const dbManager = require("../lib/db-manager");
+// check for dbSchema.json
+
+(async () => {
+  await dbManager.makeMigrationsTable();
+})();

examples/validation-from-disk.js

@@ -1,53 +1,75 @@
-const Ajv = require('ajv');
-const fse = require('fse');
-const path = require('path');
+const Ajv = require("ajv");
+const fse = require("fse");
+const path = require("path");
 
-const getSchema = (uri ) => {
-  return request.json(uri).then(function (res) {
+const getSchema = uri => {
+  return request.json(uri).then(function(res) {
     if (res.statusCode >= 400)
-      throw new Error('Loading error: ' + res.statusCode);
+      throw new Error("Loading error: " + res.statusCode);
     return res.body;
   });
-}
-
+};
 
 // const loadSchema = getSchema;
 
 async function go() {
-  const base = '../sql-json-schema/'
+  const base = "../sql-json-schema/";
 
-  const loadSchema = (uri) => {
+  const loadSchema = uri => {
     return fse.readJson(path.join(base, uri));
-  }
+  };
 
-  const schemaSchema = await fse.readJson(path.join(base, 'schema.schema.json'))
-  const ajv = new Ajv({ loadSchema, });
+  const schemaSchema = await fse.readJson(
+    path.join(base, "schema.schema.json")
+  );
+  const ajv = new Ajv({ loadSchema });
+  require("ajv-merge-patch")(ajv); // add merge and patch compatibility
 
-  ajv.compileAsync(
-    schemaSchema
-  ).then((validate) => {
-    const valid = validate(
-      {
-        "tables": [
-          {
-            "name": "users",
-            "columns": [
-              {
-                "name": "firstName",
-                "type": "float",
-                scale: 'something'
-              }
-            ]
-          }
-        ]
-      }
-    )
-    if(!valid) {
-      console.log('Error!');
+  ajv.compileAsync(schemaSchema).then(validate => {
+    const valid = validate({
+      tables: [
+        {
+          name: "users",
+          columns: [
+            {
+              name: "age",
+              type: "integer",
+              unsigned: false
+            },
+            {
+              name: "firstName",
+              type: "string"
+            },
+            {
+              name: "bio",
+              type: "text",
+              default: "This bio is currently empty."
+            },
+            {
+              name: "age",
+              type: "integer"
+            },
+            {
+              name: "mightBeValid",
+              type: "integer"
+              // , unrecognizedField: 5 // will invalidate
+            },
+            {
+              name: "friendId",
+              type: "integer",
+              unsigned: true
+            }
+          ]
+        }
+      ]
+    });
+    if (!valid) {
+      console.log("Error!");
+      console.log(validate.errors);
     } else {
-      console.log('Valid!');
+      console.log("Valid!");
     }
-  })
+  });
 }
 
-go()
+// go();

lib/builder.js

@@ -1,6 +1,7 @@
 const _ = require("lodash");
 const validateColumn = require("./validation");
 
+// Values that can go in a column's "type" field
 const types = {
   binary: (table, name, options) => {
     return table.binary(name, options.length);
@@ -55,9 +56,15 @@ const types = {
   },
   uuid: (table, name) => {
     return table.uuid(name);
+  },
+  foreign: (table, name, options) => {
+    debugger;
+    console.log(`Creating foreign key ${options.foreign}`);
+    return table.foreign(options.foreign);
   }
 };
 
+// Fields that can go in a column
 const typeProperties = {
   primary: (chain, value) => {
     if (value === true) {
@@ -77,9 +84,6 @@ const typeProperties = {
     }
     return chain;
   },
-  foreign: (table, name) => {
-    return table.foreign(name);
-  },
   references: (chain, value) => {
     return chain.references(value);
   },
@@ -100,69 +104,109 @@ const typeProperties = {
   },
   index: (chain, value) => {
     return value ? chain.index() : chain;
+  },
+  onDelete: (chain, value) => {
+    console.log(chain);
+    console.log(value);
+    return chain.onDelete(value);
   }
 };
 
-function createTable(chain, name, schema) {
+/**
+ * Creates a table with columns specified by the schema
+ * @param {*} chain
+ * @param {*} name
+ * @param {*} tableSchema
+ */
+async function createTable(chain, name, tableSchema) {
   // Usually start with knex.createTable....
-  return chain.createTable(name, table => {
-    const sawPrimary = false;
+  return await chain.createTable(name, table => {
+    _.forEach(tableSchema.columns, column => {
+      createColumn(table, column);
+    });
+  });
+}
 
-    _.forEach(schema.columns, column => {
-      const columnName = column.name;
-      // e.g., id: { type: "increments" }
-      if (_.isPlainObject(column)) {
-        validateColumn(column);
-        if (_.has(types, column.type)) {
-          let columnChain = types[column.type](table, columnName, column);
-          const order = _.uniq(
-            _.concat(
-              ["primary", "type", "unsigned", "references", "inTable"],
-              _.keys(column)
-            )
+/**
+ * Creates a column in the passed-in table using the specified column config
+ * @param {*} table
+ * @param {*} column
+ */
+async function createColumn(table, column, alter = false) {
+  const columnName = column.name;
+  // e.g., id: { type: "increments" }
+  debugger;
+  if (_.isPlainObject(column) && _.has(types, column.type)) {
+    let columnChain = types[column.type](table, columnName, column);
+    // correctly orders the properties to be chained:
+    // the ones where order is important, then all the rest
+    const order = _.uniq(
+      _.concat(
+        ["primary", "type", "unsigned", "references", "inTable"],
+        _.keys(column)
+      )
+    );
+
+    // for each item in the order
+    _.forEach(order, columnPropertyName => {
+      if (_.has(column, columnPropertyName)) {
+        // if it exists in the column def, apply the related chain method
+        const columnProperty = column[columnPropertyName];
+        if (_.has(typeProperties, columnPropertyName)) {
+          columnChain = typeProperties[columnPropertyName](
+            columnChain,
+            columnProperty
           );
-          _.forEach(order, columnPropertyName => {
-            if (_.has(column, columnPropertyName)) {
-              const columnProperty = column[columnPropertyName];
-              if (_.has(typeProperties, columnPropertyName)) {
-                columnChain = typeProperties[columnPropertyName](
-                  columnChain,
-                  columnProperty
-                );
-              }
-            }
-          });
         }
-      } else {
-        throw Error(
-          `Column '${
-            column.type
-          }' of '${name}:${columnName}' is not of recognized type`
-        );
       }
     });
-  });
+
+    // this is only for altering columns that already exist
+    if (alter) {
+      columChain = columnChain.alter();
+    }
+  } else {
+    throw Error(
+      `Column '${
+        column.type
+      }' of '${name}:${columnName}' is not of recognized type`
+    );
+  }
 }
 
-function createTables(knex, schema) {
+/**
+ * Creates a series of tables based off a db JSON schema
+ * @param {*} knex a knex instance
+ * @param {JSON} schema the JSON schema to be used as the blueprint
+ * @returns {*} a chainable knex schema object
+ */
+async function createTables(knex, schema) {
   let chain = knex.schema;
-  _.forEach(schema.tables, tableConfig => {
+  for (let i in schema.tables) {
+    const tableConfig = schema.tables[i];
     const tableName = tableConfig.name;
-    chain = createTable(chain, tableName, tableConfig);
-  });
+    chain = await createTable(chain, tableName, tableConfig);
+  }
   return chain;
 }
 
-function dropTablesIfExists(knex, schema) {
+/**
+ * Removes all tables listed in the passed-in schema
+ * @param {*} knex a knex instance
+ * @param {Object} schema the JSON schema to be used
+ * @returns {*}
+ */
+async function dropTablesIfExists(knex, schema) {
   let chain = knex.schema;
-  _.forEach(schema.tables, tableConfig => {
+  _.forEach(schema.tables.reverse(), async tableConfig => {
     const tableName = tableConfig.name;
-    chain.dropTableIfExists(tableName);
+    await chain.dropTableIfExists(tableName);
   });
   return chain;
 }
 
 module.exports = {
+  createColumn,
   createTable,
   createTables,
   dropTablesIfExists