ee-mysql-connection - npm Package Compare versions

Comparing version 0.1.7 to 0.1.8

lib/MySQLConnection.js

@@ -11,4 +11,4 @@ !function(){
 		, pluralize 	= require('pluralize')
-		, Connection 	= require('ee-db-connection') //*/require('../../ee-db-connection')
-		, QueryBuilder 	= require('ee-query-builder'); //*/require('../../ee-query-builder');
+		, Connection 	= /*require('ee-db-connection') //*/require('../../ee-db-connection')
+		, QueryBuilder 	= /*require('ee-query-builder'); //*/require('../../ee-query-builder');
 
@@ -170,181 +170,176 @@
 		 */
-		, _describe: function(callback){
-			this.listDatabases(function(err, databases){
+		, _describe: function(databases, callback){
+
+			// get definition for each database
+			async.each(databases, function(databaseName, next){
+				// get relations
+				async.wait(function(done){
+					this.listContraints(databaseName, done);
+				}.bind(this)
+
+				// get table definitions
+				, function(done){
+					this.describeTables(databaseName, done);
+				}.bind(this)
+
+				// clean up results
+				, function(err, results){
+					if(err) callback(err);
+					else {
+						next(null, {
+							  databaseName: databaseName
+							, constraints: 	results[0]
+							, tables: 		results[1]
+						});
+					}
+				}.bind(this));
+			}.bind(this)
+
+			// reformat definitions
+			, function(err, definitions) {
 				if (err) callback(err);
 				else {
+					var dbs = {};
 
-					// get definition for each database
-					async.each(databases, function(databaseName, next){
-						// get relations
-						async.wait(function(done){
-							this.listContraints(databaseName, done);
-						}.bind(this)
+					definitions.forEach(function(db){
+						var database;
 
-						// get table definitions
-						, function(done){
-							this.describeTables(databaseName, done);
-						}.bind(this)
+						if (!dbs[db.databaseName]) {
+							dbs[db.databaseName] = {};
+							Object.defineProperty(dbs[db.databaseName], 'getDatabaseName', {
+								value: function(){return db.databaseName;}
+							});
+						}
+						database = dbs[db.databaseName];
 
-						// clean up results
-						, function(err, results){
-							if(err) callback(err);
-							else {
-								next(null, {
-									  databaseName: databaseName
-									, constraints: 	results[0]
-									, tables: 		results[1]
+
+						// map tables
+						db.tables.forEach(function(definition){
+							var table;
+
+							if (!database[definition.TABLE_NAME]) {
+								database[definition.TABLE_NAME] = {
+									  name 			: definition.TABLE_NAME
+									, primaryKeys 	: []
+									, isMapping 	: false
+									, columns 		: {}
+								};
+
+								Object.defineProperty(database[definition.TABLE_NAME], 'getTableName', {
+									value: function(){return definition.TABLE_NAME;}
 								});
+								Object.defineProperty(database[definition.TABLE_NAME], 'getDatabaseName', {
+									value: function(){return db.databaseName;}
+								});
 							}
+							table = database[definition.TABLE_NAME];
+
+							table.columns[definition.COLUMN_NAME] = {
+								  name: 	 	definition.COLUMN_NAME
+								, type: 		definition.DATA_TYPE
+								, length: 		definition.CHARACTER_MAXIMUM_LENGTH || definition.NUMERIC_PRECISION
+								, nullable: 	definition.IS_NULLABLE === 'YES'
+								, isPrimary: 	false
+								, isUnique: 	false
+								, isForeignKey: false
+								, isReferenced: false
+								, mapsTo: 		[]
+								, belongsTo: 	[]
+							};
 						}.bind(this));
-					}.bind(this)
 
-					// reformat definitions
-					, function(err, definitions) {
-						if (err) callback(err);
-						else {
-							var dbs = {};
 
-							definitions.forEach(function(db){
-								var database;
+						// map constraints
+						Object.keys(db.constraints).forEach(function(tableName){
 
-								if (!dbs[db.databaseName]) {
-									dbs[db.databaseName] = {};
-									Object.defineProperty(dbs[db.databaseName], 'getDatabaseName', {
-										value: function(){return db.databaseName;}
-									});
-								}
-								database = dbs[db.databaseName];
+							// gather info
+							Object.keys(db.constraints[tableName]).forEach(function(constraintName){
+								var   constraint = db.constraints[tableName][constraintName];
 
+								constraint.rules.forEach(function(rule){
+									switch (constraint.type) {
+										case 'primary key':
+											database[tableName].columns[rule.column_name].isPrimary = true;
+											database[tableName].primaryKeys.push(rule.column_name);
+											break;
 
-								// map tables
-								db.tables.forEach(function(definition){
-									var table;
+										case 'unique':
+											database[tableName].columns[rule.column_name].isUnique = true;
+											break;
 
-									if (!database[definition.TABLE_NAME]) {
-										database[definition.TABLE_NAME] = {
-											  name 			: definition.TABLE_NAME
-											, primaryKeys 	: []
-											, isMapping 	: false
-											, columns 		: {}
-										};
+										case 'foreign key':
+											database[tableName].columns[rule.column_name].isForeignKey = true;
+											database[tableName].columns[rule.column_name].referencedTable = rule.referenced_table_name;
+											database[tableName].columns[rule.column_name].referencedColumn = rule.referenced_column_name;
+											database[tableName].columns[rule.column_name].referencedModel = database[rule.referenced_table_name];
 
-										Object.defineProperty(database[definition.TABLE_NAME], 'getTableName', {
-											value: function(){return definition.TABLE_NAME;}
-										});
-										Object.defineProperty(database[definition.TABLE_NAME], 'getDatabaseName', {
-											value: function(){return db.databaseName;}
-										});
+											// tell the other side its referenced
+											database[rule.referenced_table_name].columns[rule.referenced_column_name].belongsTo.push({
+												  targetColumn: rule.column_name
+												, name: tableName
+												, model: database[tableName]
+											});
+											database[rule.referenced_table_name].columns[rule.referenced_column_name].isReferenced = true;
+											break;
 									}
-									table = database[definition.TABLE_NAME];
+								});
+							}.bind(this));
 
-									table.columns[definition.COLUMN_NAME] = {
-										  name: 	 	definition.COLUMN_NAME
-										, type: 		definition.DATA_TYPE
-										, length: 		definition.CHARACTER_MAXIMUM_LENGTH || definition.NUMERIC_PRECISION
-										, nullable: 	definition.IS_NULLABLE === 'YES'
-										, isPrimary: 	false
-										, isUnique: 	false
-										, isForeignKey: false
-										, isReferenced: false
-										, mapsTo: 		[]
-										, belongsTo: 	[]
-									};
-								}.bind(this));
 
+							Object.keys(db.constraints[tableName]).forEach(function(constraintName){
+								var   constraint = db.constraints[tableName][constraintName];
 
-								// map constraints
-								Object.keys(db.constraints).forEach(function(tableName){
+								// check for mapping table
+								// a rule must have two memebers and may be of type primary
+								// or unique. if this rule has fks on both column we got a mapping table
+								if (constraint.rules.length === 2 && (constraint.type === 'primary key' || constraint.type === 'unique')){
+									var columns = constraint.rules.map(function(rule){ return rule.column_name; });
 
-									// gather info
-									Object.keys(db.constraints[tableName]).forEach(function(constraintName){
-										var   constraint = db.constraints[tableName][constraintName];
+									// serach for fks on both columns, go through all rules on the table, look for a fk constraint
+									if (Object.keys(db.constraints[tableName]).filter(function(checkContraintName){
+												var checkConstraint = db.constraints[tableName][checkContraintName];
 
-										constraint.rules.forEach(function(rule){
-											switch (constraint.type) {
-												case 'primary key':
-													database[tableName].columns[rule.column_name].isPrimary = true;
-													database[tableName].primaryKeys.push(rule.column_name);
-													break;
+												return checkConstraint.type === 'foreign key' && (checkConstraint.rules.filter(function(checkRule){
+													return columns.indexOf(checkRule.column_name) >= 0;
+												})).length === 1;
+											}).length === 2){
 
-												case 'unique':
-													database[tableName].columns[rule.column_name].isUnique = true;
-													break;
+										database[tableName].isMapping = true;
+										database[tableName].mappingColumns = columns;
 
-												case 'foreign key':
-													database[tableName].columns[rule.column_name].isForeignKey = true;
-													database[tableName].columns[rule.column_name].referencedTable = rule.referenced_table_name;
-													database[tableName].columns[rule.column_name].referencedColumn = rule.referenced_column_name;
-													database[tableName].columns[rule.column_name].referencedModel = database[rule.referenced_table_name];
+										// set mapping reference on tables
+										var   modelA = database[tableName].columns[columns[0]].referencedModel
+											, modelB = database[tableName].columns[columns[1]].referencedModel;
 
-													// tell the other side its referenced
-													database[rule.referenced_table_name].columns[rule.referenced_column_name].belongsTo.push({
-														  targetColumn: rule.column_name
-														, name: tableName
-														, model: database[tableName]
-													});
-													database[rule.referenced_table_name].columns[rule.referenced_column_name].isReferenced = true;
-													break;
+										modelA.columns[database[tableName].columns[columns[0]].referencedColumn].mapsTo.push({
+											  model 		: modelB
+											, column 		: modelB.columns[database[tableName].columns[columns[1]].referencedColumn]
+											, name 			: modelB.name //pluralize.plural(modelB.name)
+											, via: {
+												  model 	: database[tableName]
+												, fk 		: columns[0]
+												, otherFk 	: columns[1]
 											}
 										});
-									}.bind(this));
 
-
-									Object.keys(db.constraints[tableName]).forEach(function(constraintName){
-										var   constraint = db.constraints[tableName][constraintName];
-
-										// check for mapping table
-										// a rule must have two memebers and may be of type primary
-										// or unique. if this rule has fks on both column we got a mapping table
-										if (constraint.rules.length === 2 && (constraint.type === 'primary key' || constraint.type === 'unique')){
-											var columns = constraint.rules.map(function(rule){ return rule.column_name; });
-
-											// serach for fks on both columns, go through all rules on the table, look for a fk constraint
-											if (Object.keys(db.constraints[tableName]).filter(function(checkContraintName){
-														var checkConstraint = db.constraints[tableName][checkContraintName];
-
-														return checkConstraint.type === 'foreign key' && (checkConstraint.rules.filter(function(checkRule){
-															return columns.indexOf(checkRule.column_name) >= 0;
-														})).length === 1;
-													}).length === 2){
-
-												database[tableName].isMapping = true;
-												database[tableName].mappingColumns = columns;
-
-												// set mapping reference on tables
-												var   modelA = database[tableName].columns[columns[0]].referencedModel
-													, modelB = database[tableName].columns[columns[1]].referencedModel;
-
-												modelA.columns[database[tableName].columns[columns[0]].referencedColumn].mapsTo.push({
-													  model 		: modelB
-													, column 		: modelB.columns[database[tableName].columns[columns[1]].referencedColumn]
-													, name 			: pluralize.plural(modelB.name)
-													, via: {
-														  model 	: database[tableName]
-														, fk 		: columns[0]
-														, otherFk 	: columns[1]
-													}
-												});
-
-												// don't add mappings to myself twice
-												if (modelB !== modelA) {
-													modelB.columns[database[tableName].columns[columns[1]].referencedColumn].mapsTo.push({
-														  model 		: modelA
-														, column 		: modelA.columns[database[tableName].columns[columns[0]].referencedColumn]
-														, name 			: pluralize.plural(modelA.name)
-														, via: {
-															  model 	: database[tableName]
-															, fk 		: columns[1]
-															, otherFk 	: columns[0]
-														}
-													});
+										// don't add mappings to myself twice
+										if (modelB !== modelA) {
+											modelB.columns[database[tableName].columns[columns[1]].referencedColumn].mapsTo.push({
+												  model 		: modelA
+												, column 		: modelA.columns[database[tableName].columns[columns[0]].referencedColumn]
+												, name 			: modelA.name //pluralize.plural(modelA.name)
+												, via: {
+													  model 	: database[tableName]
+													, fk 		: columns[1]
+													, otherFk 	: columns[0]
 												}
-											}
+											});
 										}
-									}.bind(this));
-								}.bind(this));
+									}
+								}
 							}.bind(this));
+						}.bind(this));
+					}.bind(this));
 
-							callback(null, dbs);
-						}
-					}.bind(this));
+					callback(null, dbs);
 				}
@@ -351,0 +346,0 @@ }.bind(this));

package.json

 {
       "name"                        : "ee-mysql-connection"
     , "description"                 : "mysql connection abstraction for ee-orm"
-    , "version"                     : "0.1.7"
+    , "version"                     : "0.1.8"
     , "homepage"                    : "https://github.com/eventEmitter/ee-mysql-connection"
@@ -24,3 +24,3 @@ , "author"                      : "Michael van der Weg <[e-mail]> (http://eventemitter.com/)"
         , "ee-log"                  : "0.2.x"
-        , "ee-async"                : "0.1.x"
+        , "ee-async"                : "0.2.x"
         , "ee-argv"                 : "0.1.x"
@@ -27,0 +27,0 @@ , "ee-project"              : "0.2.x"

test.js

@@ -9,2 +9,20 @@
 
-	new MySQLConnection();
+
+    var connection = new MySQLConnection({
+          host      : '10.80.100.1'
+        , username  : 'root'
+        , password  : 'palm15/20singlemalt'
+        , port      : 3306
+        , database  : 'eventbooster'
+    });
+
+
+    connection.on('load', function(err) {
+        log(err);
+
+        connection.describe(['eventbooster'], function(err, description) {
+            //log(err, description);
+        });
+    });
+
+    

test/default.js

@@ -21,8 +21,8 @@
 			schema = new Schema({
-				  dialect: 	'postgres'
+				  dialect: 	'mysql'
 				, host: 	process.ENV.DB_HOST
 				, port: 	process.ENV.DB_PORT
-				, user: 	'postgres'
+				, user: 	process.ENV.DB_USER
 				, password: process.ENV.DB_PASS
-				, database: 'wpm'
+				, database: 'eventbox'
 				, models: 	path.join(__dirname, '../schema')
@@ -29,0 +29,0 @@ });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

24914

increased by0.21%

Lines of code

667

increased by1.21%

Dependency changes

• - Removedee-async@0.1.0(transitive)

• Updatedee-async@0.2.x