lib/schemabuilder.js

Schema Builder

var _ = require('lodash'); var Common = require('./common').Common; var Helpers = require('./helpers').Helpers; var SchemaBuilder = function(knex) { this.knex = knex; this.client = knex.client; this.grammar = knex.schemaGrammar; this.columns = []; this.commands = []; this.bindings = []; this.flags = {}; _.bindAll(this, 'handleResponse'); }; var toClone = ['columns', 'commands', 'bindings', 'flags']; _.extend(SchemaBuilder.prototype, Common, { _source: 'SchemaBuilder', clone: function() { return _.reduce(toClone, function(memo, key) { memo[key] = Helpers.deepClone(this[key]); return memo; }, this.instance(), this); },

A callback from the table building Knex.schemaBuilder calls.

callback: function(callback) { if (callback) callback.call(this, this); return this; },

Determine if the blueprint has a create command.

creating: function() { for (var i = 0, l = this.commands.length; i < l; i++) { if (this.commands[i].name == 'createTable') return true; } return false; },

Sets the engine to use when creating the table in MySql

engine: function(name) { if (!this.creating()) throw new Error('The `engine` modifier may only be used while creating a table.'); this.flags.engine = name; return this; },

Sets the character set for the table in MySql

charset: function(charset) { if (!this.creating()) throw new Error('The `engine` modifier may only be used while creating a table.'); this.flags.charset = charset; return this; },

Sets the collation for the table in MySql

collate: function(collation) { if (!this.creating()) throw new Error('The `engine` modifier may only be used while creating a table.'); this.flags.collation = collation; return this; },

Adds a comment to the current table being created.

comment: function(comment) { return this._addCommand('comment', {comment: comment}); },

Indicate that the given columns should be dropped.

dropColumn: function(columns) { if (!_.isArray(columns)) columns = columns ? [columns] : []; return this._addCommand('dropColumn', {columns: columns}); },

Indicate that the given columns should be dropped.

dropColumns: function() { return this.dropColumn(arguments); },

Indicate that the given primary key should be dropped.

dropPrimary: function(index) { return this._dropIndexCommand('dropPrimary', index); },

Indicate that the given unique key should be dropped.

dropUnique: function(index) { return this._dropIndexCommand('dropUnique', index); },

Indicate that the given index should be dropped.

dropIndex: function(index) { return this._dropIndexCommand('dropIndex', index); },

Indicate that the given foreign key should be dropped.

dropForeign: function(index) { return this._dropIndexCommand('dropForeign', index); },

Specify the primary key(s) for the table.

primary: function(columns, name) { return this._indexCommand('primary', columns, name); },

Specify a unique index for the table.

unique: function(columns, name) { return this._indexCommand('unique', columns, name); },

Specify an index for the table.

index: function(columns, name) { return this._indexCommand('index', columns, name); },

Rename a column from one value to another value.

renameColumn: function(from, to) { return this._addCommand('renameColumn', {from: from, to: to}); },

Specify a foreign key for the table, also getting any relevant info from the chain during column.

foreign: function(column, name) { var chained, chainable = this._indexCommand('foreign', column, name); if (_.isObject(column)) { chained = _.pick(column, 'foreignColumn', 'foreignTable', 'commandOnDelete', 'commandOnUpdate'); } return _.extend(chainable, ForeignChainable, chained); },

Create a new auto-incrementing column on the table.

increments: function(column) { return this._addColumn('integer', (column || 'id'), {isUnsigned: true, autoIncrement: true, length: 11}); },

Create a new auto-incrementing big-int on the table

bigIncrements: function(column) { return this._addColumn('bigInteger', (column || 'id'), {isUnsigned: true, autoIncrement: true}); },

Create a new string column on the table.

string: function(column, length) { return this._addColumn('string', column, {length: (length || 255)}); },

Alias varchar to string

varchar: function(column, length) { return this.string(column, length); },

Create a new text column on the table.

text: function(column, length) { return this._addColumn('text', column, {length: (length || false)}); },

Create a new integer column on the table.

integer: function(column, length) { return this._addColumn('integer', column, {length: (length || 11)}); },

Create a new biginteger column on the table

bigInteger: function(column) { return this._addColumn('bigInteger', column); },

Create a new tinyinteger column on the table.

tinyInteger: function(column) { return this._addColumn('tinyInteger', column); },

Alias for tinyinteger column.

tinyint: function(column) { return this.tinyInteger(column); },

Create a new float column on the table.

float: function(column, precision, scale) { return this._addColumn('float', column, { precision: (precision == null ? 8 : precision), scale: (scale == null ? 2 : scale) }); },

Create a new decimal column on the table.

decimal: function(column, precision, scale) { return this._addColumn('decimal', column, { precision: (precision == null ? 8 : precision), scale: (scale == null ? 2 : scale) }); },

Alias to "bool"

boolean: function(column) { return this.bool(column); },

Create a new boolean column on the table

bool: function(column) { return this._addColumn('boolean', column); },

Create a new date column on the table.

date: function(column) { return this._addColumn('date', column); },

Create a new date-time column on the table.

dateTime: function(column) { return this._addColumn('dateTime', column); },

Create a new time column on the table.

time: function(column) { return this._addColumn('time', column); },

Create a new timestamp column on the table.

timestamp: function(column) { return this._addColumn('timestamp', column); },

Add creation and update dateTime's to the table.

timestamps: function() { this.dateTime('created_at'); this.dateTime('updated_at'); },

Alias to enum.

"enum": function(column, allowed) { return this.enu(column, allowed); },

Create a new enum column on the table.

enu: function(column, allowed) { if (!_.isArray(allowed)) allowed = [allowed]; return this._addColumn('enum', column, {allowed: allowed}); },

Create a new bit column on the table.

bit: function(column, length) { return this._addColumn('bit', column, {length: (length || false)}); },

Create a new binary column on the table.

binary: function(column) { return this._addColumn('binary', column); },

Create a new json column on the table.

json: function(column) { return this._addColumn('json', column); },

Create a new uuid column on the table.

uuid: function(column) { return this._addColumn('uuid', column); }, specificType: function(column, type) { return this._addColumn('specificType', column, {specific: type}); },

Create a new drop index command on the blueprint. If the index is an array of columns, the developer means to drop an index merely by specifying the columns involved.

_dropIndexCommand: function(type, index) { var columns = []; if (_.isArray(index)) { columns = index; index = null; } return this._indexCommand(type, columns, index); },

Add a new index command to the blueprint. If no name was specified for this index, we will create one using a basic convention of the table name, followed by the columns, followed by an index type, such as primary or index, which makes the index unique.

_indexCommand: function(type, columns, index) { index || (index = null); if (!_.isArray(columns)) columns = columns ? [columns] : []; if (index === null) { var table = this.table.replace(/\.|-/g, '_'); index = (table + '_' + _.map(columns, function(col) { return col.name || col; }).join('_') + '_' + type).toLowerCase(); } return this._addCommand(type, {index: index, columns: columns}); },

Add a new column to the blueprint.

_addColumn: function(type, name, parameters) { if (!name) throw new Error('A `name` must be defined to add a column'); var column = _.extend({type: type, name: name}, ChainableColumn, parameters); this.columns.push(column); return column; },

Add a new command to the blueprint.

_addCommand: function(name, parameters) { var command = _.extend({name: name}, parameters); this.commands.push(command); return command; } }); var ForeignChainable = {

Sets the "column" that the current column references as the a foreign key

references: function(column) { this.isForeign = true; this.foreignColumn = column || null; return this; },

Sets the "table" where the foreign key column is located.

inTable: function(table) { this.foreignTable = table || null; return this; },

SQL command to run "onDelete"

onDelete: function(command) { this.commandOnDelete = command || null; return this; },

SQL command to run "onUpdate"

onUpdate: function(command) { this.commandOnUpdate = command || null; return this; } }; var ChainableColumn = _.extend({

Sets the default value for a column. For boolean columns, we'll permit 'false' to be used as default values.

defaultTo: function(value) { if (this.type === 'boolean') { if (value === 'false') value = 0; value = (value ? 1 : 0); } this.defaultValue = value; return this; },

Sets an integer as unsigned, is a no-op if the column type is not an integer.

unsigned: function() { this.isUnsigned = true; return this; },

Allows the column to contain null values.

nullable: function() { this.isNullable = true; return this; },

Disallow the column from containing null values.

notNull: function() { this.isNullable = false; return this; },

Disallow the column from containing null values.

notNullable: function() { this.isNullable = false; return this; },

Adds an index on the specified column.

index: function(name) { this.isIndex = name || true; return this; },

Sets this column as the primary key.

primary: function(name) { if (!this.autoIncrement) { this.isPrimary = name || true; } return this; },

Sets this column as unique.

unique: function(name) { this.isUnique = name || true; return this; },

Sets the column to be inserted after another, used in MySql alter tables.

after: function(name) { this.isAfter = name; return this; },

Adds a comment to this column.

comment: function(comment) { this.isCommented = comment || null; return this; } }, ForeignChainable); exports.SchemaBuilder = SchemaBuilder;