created createConnection function to simplify connection creation

src/connection/ConnectionManager.ts

@@ -48,14 +48,18 @@ export class ConnectionManager {
     /**
      * Creates and adds a new connection with given driver.
      */
-    addConnection(driver: Driver): void;
-    addConnection(name: string, driver: Driver): void;
-    addConnection(name: any, driver?: Driver): void {
+    createConnection(driver: Driver): Connection;
+    createConnection(name: string, driver: Driver): Connection;
+    createConnection(name: string|Driver, driver?: Driver): Connection {
         if (typeof name === "object") {
             driver = <Driver> name;
+        }
+        if (!name) {
             name = "default";
         }
-        this.connections.push(new Connection(name, driver));
+        const connection = new Connection(<string> name, driver);
+        this.connections.push(connection);
+        return connection;
     }
 
     /**
@@ -63,6 +67,8 @@ export class ConnectionManager {
      * connection.
      */
     getConnection(name: string = "default"): Connection {
+        if (!name)
+            name = "default";
         const foundConnection = this.connections.find(connection => connection.name === name);
         if (!foundConnection)
             throw new ConnectionNotFoundError(name);
@@ -78,7 +84,7 @@ export class ConnectionManager {
     importEntitiesFromDirectories(connectionName: string, paths: string[]): void;
     importEntitiesFromDirectories(connectionNameOrPaths: string|string[], paths?: string[]): void {
         let connectionName = "default";
-        if (typeof connectionNameOrPaths === "string") {
+        if (paths) {
             connectionName = <string> connectionNameOrPaths;
         } else {
             paths = <string[]> connectionNameOrPaths;
@@ -95,7 +101,7 @@ export class ConnectionManager {
     importSubscribersFromDirectories(connectionName: string, paths: string[]): void;
     importSubscribersFromDirectories(connectionNameOrPaths: string|string[], paths?: string[]): void {
         let connectionName = "default";
-        if (typeof connectionNameOrPaths === "string") {
+        if (paths) {
             connectionName = <string> connectionNameOrPaths;
         } else {
             paths = <string[]> connectionNameOrPaths;
@@ -116,7 +122,7 @@ export class ConnectionManager {
     importEntities(connectionName: string, entities: Function[]): void;
     importEntities(connectionNameOrEntities: string|Function[], entities?: Function[]): void {
         let connectionName = "default";
-        if (typeof connectionNameOrEntities === "string") {
+        if (entities) {
             connectionName = <string> connectionNameOrEntities;
         } else {
             entities = <Function[]> connectionNameOrEntities;

src/typeorm.ts

@@ -10,8 +10,49 @@ let mysql = require("mysql");
  */
 export const connectionManager = new ConnectionManager();
 
+export interface CreateConnectionParameters {
+    driver: "mysql";
+    connectionName?: string;
+    connectionOptions?: ConnectionOptions;
+    entities?: Function[];
+    subscribers?: Function[];
+    entityDirectories?: string[];
+    subscriberDirectories?: string[];
+}
+
+export function createConnection(parameters: CreateConnectionParameters): Promise<Connection> {
+
+    let connection: Connection;
+    switch (parameters.driver) {
+        case "mysql":
+            connection = connectionManager.createConnection(parameters.connectionName, new MysqlDriver(mysql));
+            break;
+        default:
+            throw new Error(`Wrong driver ${parameters.driver} given. Supported drivers are: "mysql"`);
+    }
+
+    if (parameters.entityDirectories && parameters.entityDirectories.length > 0)
+        connectionManager.importEntitiesFromDirectories(parameters.connectionName, parameters.entityDirectories);
+
+    if (parameters.entities) {
+        connectionManager.importEntities(parameters.connectionName, parameters.entities);
+    }
+
+    if (parameters.subscriberDirectories && parameters.subscriberDirectories.length > 0)
+        connectionManager.importSubscribersFromDirectories(parameters.connectionName, parameters.subscriberDirectories);
+
+    // if (parameters.subscribers)
+    //     connectionManager.importSubscribers(parameters.subscribers);
+
+    return connection
+        .connect(parameters.connectionOptions)
+        .then(() => connection);
+}
+
+
 /**
  * Creates a new connection to mysql. Imports documents and subscribers from the given directories.
+ * @deprecated
  */
 export function createMysqlConnection(options: string, documentDirectories: string[]|Function[], subscriberDirectories?: string[]): Promise<Connection>;
 export function createMysqlConnection(options: ConnectionOptions, documentDirectories: string[]|Function[], subscriberDirectories?: string[]): Promise<Connection>;
@@ -20,19 +61,19 @@ export function createMysqlConnection(configuration: string|ConnectionOptions, d
         configuration = { url: <string> configuration };
     }
 
-    this.connectionManager.addConnection(new MysqlDriver(mysql));
+    connectionManager.createConnection(new MysqlDriver(mysql));
 
     if (documentDirectories && documentDirectories.length > 0) {
         if (typeof documentDirectories[0] === "string") {
-            this.connectionManager.importEntitiesFromDirectories(<string[]> documentDirectories);
+            connectionManager.importEntitiesFromDirectories(<string[]> documentDirectories);
         } else {
-            this.connectionManager.importEntities(<Function[]> documentDirectories);
+            connectionManager.importEntities(<Function[]> documentDirectories);
         }
     }
 
     if (subscriberDirectories && subscriberDirectories.length > 0)
-        this.connectionManager.importSubscribersFromDirectories(subscriberDirectories);
+        connectionManager.importSubscribersFromDirectories(subscriberDirectories);
 
-    const connection = this.connectionManager.getConnection();
+    const connection = connectionManager.getConnection();
     return connection.connect(<ConnectionOptions> configuration).then(() => connection);
 }

test/integration/sample1-simple-entity.ts

@@ -1,8 +1,7 @@
 import * as chai from "chai";
 import {expect} from "chai";
 import {Connection} from "../../src/connection/Connection";
-import {createMysqlConnection} from "../../src/typeorm";
-import {ConnectionOptions} from "../../src/connection/ConnectionOptions";
+import {createConnection, CreateConnectionParameters} from "../../src/typeorm";
 import {Repository} from "../../src/repository/Repository";
 import {SchemaCreator} from "../../src/schema-creator/SchemaCreator";
 import {Post} from "../../sample/sample1-simple-entity/entity/Post";
@@ -14,21 +13,25 @@ describe("insertion", function() {
     // Configuration
     // -------------------------------------------------------------------------
 
-    let options: ConnectionOptions = {
-        host: "192.168.99.100",
-        port: 3306,
-        username: "root",
-        password: "admin",
-        database: "test",
-        autoSchemaCreate: true
+    const parameters: CreateConnectionParameters = {
+        driver: "mysql",
+        connectionOptions: {
+            host: "192.168.99.100",
+            port: 3306,
+            username: "root",
+            password: "admin",
+            database: "test",
+            autoSchemaCreate: true
+        },
+        entities: [Post]
     };
     
     // connect to db
     let connection: Connection;
     before(function() {
-        return createMysqlConnection(options, [Post]).then(conn => {
-            connection = conn;
-        }).catch(e => console.log("Error during connection to db: " + e));
+        return createConnection(parameters)
+            .then(con => connection = con)
+            .catch(e => console.log("Error during connection to db: " + e));
     });
 
     after(function() {
@@ -39,7 +42,8 @@ describe("insertion", function() {
     function reloadDatabase() {
         return connection.driver
             .clearDatabase()
-            .then(() => new SchemaCreator(connection).create());
+            .then(() => new SchemaCreator(connection).create())
+            .catch(e => console.log("Error during schema re-creation: ", e));
     }
 
     let postRepository: Repository<Post>;